• Top
    • Documentation
    • Books
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
    • Community
    • Proof-automation
    • Macro-libraries
    • ACL2
      • Theories
      • Rule-classes
      • Proof-builder
      • Recursion-and-induction
      • Hons-and-memoization
      • Events
      • Parallelism
      • History
      • Programming
        • Defun
        • Declare
        • System-utilities
        • Stobj
        • State
        • Mutual-recursion
        • Memoize
        • Mbe
        • Io
        • Defpkg
        • Apply$
        • Loop$
          • Loop$-primer
            • Lp-section-8
            • Lp-section-10
            • Lp-section-6
            • Lp-section-9
            • Lp-section-17
            • Lp-section-16
            • Lp-section-15
            • Lp-section-11
            • Lp-section-4
            • Lp-section-7
            • Lp-section-13
            • Lp-section-12
            • Lp-section-14
            • Lp-section-5
            • Lp-section-0
            • Lp-section-2
            • Lp-section-18
            • Lp-section-3
            • Lp-section-1
              • Lp-background-review-2-answers
              • Lp-background-review-1-answers
              • Lp-background-review-1
              • Lp-background-review-2
            • Do-loop$
            • For-loop$
            • Loop$-recursion
            • Stating-and-proving-lemmas-about-loop$s
            • Loop$-recursion-induction
            • Do$
          • Programming-with-state
          • Arrays
          • Characters
          • Time$
          • Defconst
          • Defmacro
          • Loop$-primer
            • Lp-section-8
            • Lp-section-10
            • Lp-section-6
            • Lp-section-9
            • Lp-section-17
            • Lp-section-16
            • Lp-section-15
            • Lp-section-11
            • Lp-section-4
            • Lp-section-7
            • Lp-section-13
            • Lp-section-12
            • Lp-section-14
            • Lp-section-5
            • Lp-section-0
            • Lp-section-2
            • Lp-section-18
            • Lp-section-3
            • Lp-section-1
              • Lp-background-review-2-answers
              • Lp-background-review-1-answers
              • Lp-background-review-1
              • Lp-background-review-2
            • Fast-alists
            • Evaluation
            • Guard
            • Equality-variants
            • Compilation
            • Hons
            • ACL2-built-ins
              • Let
              • Declare
              • Mbe
              • Apply$
              • Fmt
              • Loop$
                • Loop$-primer
                  • Lp-section-8
                  • Lp-section-10
                  • Lp-section-6
                  • Lp-section-9
                  • Lp-section-17
                  • Lp-section-16
                  • Lp-section-15
                  • Lp-section-11
                  • Lp-section-4
                  • Lp-section-7
                  • Lp-section-13
                  • Lp-section-12
                  • Lp-section-14
                  • Lp-section-5
                  • Lp-section-0
                  • Lp-section-2
                  • Lp-section-18
                  • Lp-section-3
                  • Lp-section-1
                    • Lp-background-review-2-answers
                    • Lp-background-review-1-answers
                    • Lp-background-review-1
                    • Lp-background-review-2
                  • Do-loop$
                  • For-loop$
                  • Loop$-recursion
                  • Stating-and-proving-lemmas-about-loop$s
                  • Loop$-recursion-induction
                  • Do$
                • Return-last
                • Mv-let
                • Df
                • Pseudo-termp
                • Defwarrant
                • Time$
                • Mbt
                • Ec-call
                • Mv-nth
                • Sys-call
                • Msg
                • Er
                • Value-triple
                • O-p
                • Comp
                • Member
                • O<
                • Cw
                • Flet
                • Or
                • Hons
                • Cbd
                • Mv
                • Defbadge
                • Append
                • *ACL2-exports*
                • Comment
                • Eql
                • List
                • Unsigned-byte-p
                • Posp
                • Natp
                • The
                • Nth
                • And
                • Len
                • Time-tracker
                • Term-order
                • True-listp
                • Msgp
                • Booleanp
                • <
                • If
                • Pseudo-term-listp
                • +
                • Not
                • With-global-stobj
                • Bitp
                • Equal
                • Cdr
                • Car
                • String-listp
                • Nat-listp
                • Implies
                • Iff
                • Character-listp
                • Alistp
                • Cons
                • Symbol-listp
                • Macrolet
                • Quote
                • Integerp
                • Consp
                • True-list-listp
                • State-global-let*
                • Compress1
                • Symbolp
                • Stringp
                • *common-lisp-symbols-from-main-lisp-package*
                • Characterp
                • Prog2$
                • *
                • Last-prover-steps
                • Hons-acons
                • Let*
                • Eq
                • With-guard-checking
                • @
                • Length
                • With-local-stobj
                • Hard-error
                • -
                • Zp
                • Search
                • Intersection$
                • Assign
                • Aset1
                • Symbol-name
                • Union$
                • Set-gc-strategy
                • In-tau-intervalp
                • Cons-with-hint
                • Break-on-error
                • Pand
                • Case-match
                • Fast-alist-fork
                • Sys-call+
                • Signed-byte-p
                • ACL2-count
                • Remove-duplicates
                • With-serialize-character
                • Observation
                • Hons-resize
                • Make-tau-interval
                • Assoc
                • Logbitp
                • Termp
                • Position
                • *standard-co*
                • Hons-acons!
                • Update-nth
                • Aref1
                • Symbol-alistp
                • Read-run-time
                • Take
                • Symbol-package-name
                • Hons-wash
                • Keywordp
                • Expt
                • Coerce
                • Get-internal-time
                • Intern
                • Non-exec
                • Case
                • Standard-oi
                • Standard-co
                • Formula
                • Atom
                • Without-evisc
                • Good-bye
                • Ash
                • With-local-state
                • Spec-mv-let
                • Intern-in-package-of-symbol
                • Binary-+
                • <=
                • With-fast-alist
                • Set-difference$
                • Hons-clear
                • Flush-compress
                • Rationalp
                • Por
                • Rassoc
                • Logand
                • Remove-assoc
                • =
                • Nthcdr
                • Pargs
                • Nfix
                • Hons-copy
                • Alphorder
                • Subsetp
                • Floor
                • Remove1-assoc
                • No-duplicatesp
                • Mv-list
                • Canonical-pathname
                • Aset2
                • Serialize-read
                • Random$
                • Fmt-to-comment-window
                • F-put-global
                • Compress2
                • Concatenate
                • Fast-alist-clean
                • Assert$
                • Remove
                • Remove1
                • Intersectp
                • Endp
                • Put-assoc
                • Princ$
                • Primitive
                • Keyword-value-listp
                • True-list-fix
                • Swap-stobjs
                • Integer-listp
                • Illegal
                • Hons-get
                • With-output-lock
                • Setenv$
                • Open-output-channel!
                • Fast-alist-free
                • Er-progn
                • Cw-print-base-radix
                • Reverse
                • Cond
                • Complex
                • Add-to-set
                • Truncate
                • Digit-char-p
                • Code-char
                • Char-code
                • Set-print-case
                • Set-print-base
                • Read-ACL2-oracle
                • Error1
                • Print-object$
                • Plet
                • Logior
                • Integer-length
                • Zip
                • With-live-state
                • Hons-assoc-equal
                • Extend-pathname
                • In-package
                • With-guard-checking-event
                • Term-listp
                • Print-object$+
                • Fmx-cw
                • String
                • Mod
                • Unary--
                • Set-print-radix
                • Resize-list
                • Pkg-witness
                • Revappend
                • Null
                • Term-list-listp
                • Make-fast-alist
                • Header
                • Boole$
                • Subseq
                • Logxor
                • With-guard-checking-error-triple
                • /
                • Make-list
                • Char-upcase
                • Char-downcase
                • Strip-cars
                • Set-fmt-hard-right-margin
                • Make-ord
                • Ifix
                • Fast-alist-free-on-exit
                • F-get-global
                • Aref2
                • Standard-char-p
                • Lognot
                • Must-be-equal
                • Integer-range-p
                • Getenv$
                • Binary-append
                • Er-hard
                • Eqlablep
                • Cpu-core-count
                • Boolean-listp
                • Allocate-fixnum-range
                • ACL2-numberp
                • Butlast
                • Pairlis$
                • Mod-expt
                • Hons-equal
                • Gc$
                • Substitute
                • Ceiling
                • With-stolen-alist
                • Mv?-let
                • String-upcase
                • String-downcase
                • Round
                • Count
                • Char
                • Sys-call-status
                • Progn$
                • Pprogn
                • Lexorder
                • Hons-summary
                • Break$
                • Assert*
                • Alpha-char-p
                • Strip-cdrs
                • Serialize-write
                • Keyword-listp
                • Upper-case-p
                • Lower-case-p
                • Logeqv
                • List*
                • Last
                • Proofs-co
                • Maximum-length
                • Fix
                • Explode-nonnegative-integer
                • Eqlable-listp
                • Dimensions
                • Default
                • Arity
                • Sublis
                • Max
                • Evenp
                • Explode-atom
                • Change
                • Zerop
                • String<
                • String-equal
                • Abs
                • Set-print-base-radix
                • Print-base-p
                • Nonnegative-integer-quotient
                • Intern$
                • Getprop
                • Binary-*
                • Aset1-trusted
                • Symbol<
                • String-append
                • Rfix
                • Mv?
                • Logic-fns-list-listp
                • Fast-alist-fork!
                • Er-hard?
                • Char-equal
                • 1+
                • *standard-oi*
                • Sys-call*
                • Pos-listp
                • Mbt*
                • Hons-wash!
                • Hons-clear!
                • Signum
                • Rem
                • Real/rationalp
                • Rational-listp
                • O-first-coeff
                • Logic-fnsp
                • Logic-fns-listp
                • Hons-copy-persistent
                • Gc-strategy
                • Fast-alist-summary
                • String>=
                • String<=
                • Acons
                • O-first-expt
                • Fast-alist-clean!
                • >=
                • >
                • Subst
                • Logcount
                • Getpropc
                • Evens
                • Er-soft
                • Digit-to-char
                • Comp-gcl
                • Atom-listp
                • Arities-okp
                • ACL2-number-listp
                • /=
                • Cadr
                • *standard-ci*
                • Unary-/
                • The-true-list
                • Realfix
                • O-rst
                • Fast-alist-len
                • Complex/complex-rationalp
                • Array2p
                • Array1p
                • Logtest
                • Logandc1
                • Char<
                • Trace-co
                • Putprop
                • Get-real-time
                • Eqlable-alistp
                • Count-keys
                • Assoc-string-equal
                • Logorc1
                • Logandc2
                • Denominator
                • 1-
                • Packn
                • Logic-termp
                • Logic-term-list-listp
                • Fmt!
                • Fms
                • Cw!
                • Assoc-keyword
                • String>
                • Numerator
                • Logorc2
                • Lognor
                • Char>=
                • Update-nth-array
                • The-number
                • Odds
                • Makunbound-global
                • Make-character-list
                • Make
                • List$
                • Int=
                • Get-cpu-time
                • Fmt-to-comment-window!
                • Fms!
                • F-boundp-global
                • Complex-rationalp
                • Alist-to-doublets
                • Access
                • Min
                • Lognand
                • Listp
                • Identity
                • Char>
                • Char<=
                • Zpf
                • Standard-char-listp
                • O-finp
                • Number-subtrees
                • Logic-term-listp
                • Last-cdr
                • Fmt1!
                • Fmt-to-comment-window!+
                • Character-alistp
                • Oddp
                • Minusp
                • Imagpart
                • Conjugate
                • Xor
                • Unquote
                • String-alistp
                • Packn-pos
                • Maybe-flush-and-compress1
                • Kwote
                • Fmt1
                • Fmt-to-comment-window+
                • Cw-print-base-radix!
                • Alist-keys-subsetp
                • Realpart
                • Plusp
                • First
                • Symbol-name-lst
                • R-symbol-alistp
                • R-eqlable-alistp
                • Fmx
                • Cw!+
                • Cons-subtrees
                • Cons-count-bounded
                • Cddr
                • Caar
                • Proper-consp
                • Kwote-lst
                • Improper-consp
                • Cw+
                • Rest
                • Standard-char-p+
                • Mbe1
                • Caddr
                • Pairlis-x2
                • Pairlis-x1
                • O>=
                • O<=
                • O-infp
                • Merge-sort-lexorder
                • Fix-true-list
                • Cdddr
                • Set-fmt-soft-right-margin
                • Real-listp
                • O>
                • Cddar
                • Cdar
                • Cdadr
                • Cdaar
                • Cadar
                • Caadr
                • Caaar
                • Cadddr
                • Caddar
                • Third
                • Tenth
                • Sixth
                • Seventh
                • Second
                • Ninth
                • Fourth
                • Fifth
                • Eighth
                • Cddddr
                • Cdddar
                • Cddadr
                • Cddaar
                • Cdaddr
                • Cdadar
                • Cdaadr
                • Cdaaar
                • Cadadr
                • Cadaar
                • Caaddr
                • Caadar
                • Caaadr
                • Caaaar
                • Hons-shrink-alist!
                • Hons-shrink-alist
                • Flush-hons-get-hash-table-link
                • Delete-assoc
              • Developers-guide
              • System-attachments
              • Advanced-features
              • Set-check-invariant-risk
              • Numbers
              • Efficiency
              • Irrelevant-formals
              • Introduction-to-programming-in-ACL2-for-those-who-know-lisp
              • Redefining-programs
              • Lists
              • Invariant-risk
              • Errors
              • Defabbrev
              • Conses
              • Alists
              • Set-register-invariant-risk
              • Strings
              • Program-wrapper
              • Get-internal-time
              • Basics
              • Packages
              • Oracle-eval
              • Defmacro-untouchable
              • <<
              • Primitive
              • Revert-world
              • Unmemoize
              • Set-duplicate-keys-action
              • Symbols
              • Def-list-constructor
              • Easy-simplify-term
              • Defiteration
              • Fake-oracle-eval
              • Defopen
              • Sleep
            • Operational-semantics
            • Real
            • Start-here
            • Debugging
            • Miscellaneous
            • Output-controls
            • Macros
            • Interfacing-tools
          • Interfacing-tools
          • Hardware-verification
          • Software-verification
          • Math
          • Testing-utilities
        • Lp-section-1

        Lp-background-review-2

        Review of apply$ and related concepts

        Below are some questions designed to review basic knowledge of apply$ and related concepts used in the semantics of loop$. For our answers see lp-background-review-2-answers.

        But our answers are sometimes quite long and elaborate — more like little lectures on the subject than just answers. So don't expect to reproduce our answers. It's up to you to decide if you know this stuff. As you use loop$, ACL2 will print warnings and error messages about functions not having badges or warrants or expressions not being tame. We don't want your reaction to be “Ack! What's that all about?” We want it to be at least “Oh yes, I remember now.” We recommend that after you've read and answered the questions, you read our answers even if you're pretty confident in your answers.

        ——————————

        Consider these events, executed as the first three events in new ACL2 sessions.

        (include-book "projects/apply/top" :dir :system)
        
        (defun sq (x)
          (declare (xargs :guard (natp x)))
          (* x x))
        
        (defun ghi (fn lst)
          (declare (xargs :guard (and (apply$-guard fn '(nil))
                                      (true-listp lst))))
          (cond
            ((endp lst) nil)
            (t (cons (apply$ fn (list (car lst)))
                     (ghi fn (cdr lst))))))

        The three events are executed without error and sq and ghi are admitted in :logic mode. By the way, we're naming certain functions in these reviews with consecutive letters of the alphabet, e.g., abc, def, ghi, jkl, mno, etc. These names are not mnemonic or acronyms. Don't read anything into the names! Note that unlike the review of elementary ACL2 features (see lp-background-review-1), here we define (sq x) with a guard of (natp x). Both sq and ghi are guard verified upon admission.

        ——————————

        1: What is the value of (ghi 'sq '(1 2 3))? Hint: This is a trick question!

        ——————————

        2: How do you assign a badge and warrant to sq?

        ——————————

        3: What is the name of the “warrant function for sq?” What does (warrant sq) abbreviate? What does (warrant sq) imply about badge and apply$?

        ——————————

        4: Can ghi be warranted? If so, what command do you type?

        ——————————

        5: What is the name of the warrant function for ghi? Explain what the warrant for ghi tells us.

        ——————————

        6: The following definition is admissible. Can it be warranted?

        (defun mno (x y z)
          (if (endp x)
              z
              (apply$ y
                      (list (car x)
                            (mno (cdr x) y z)))))
        ——————————

        7: Is (equal (mno x 'cons y) (append x y)) a theorem?

        ——————————

        8: The following defun is admissible but cannot be warranted. Why?

        (defun xyz (x) (apply$ x (list x)))
        ——————————

        9: Recall ghi as defined at the beginning of this review. Assume sq has been warranted. What is the value of (ghi 'sq '(1 2 3))?

        ——————————

        10: Is (nat-listp (ghi 'sq lst)) a theorem? If not, what theorem does this suggest?

        ——————————

        11: What is the value of the term below?

        (ghi (lambda$ (e) (ghi 'sq e))
             '((1 2 3)
               (4 5 6)
               (7 8 9)))
        ——————————

        12: Suppose you want to define jkl to be something like what's shown below and you want the guards verified.

        (defun jkl (lst)
          (declare (xargs :guard ...))
          (ghi (lambda$ (e) (ghi 'sq e)) lst)))

        Notice that the body of jkl is the doubly nested ghi term just tested, except now instead of applying it to a constant list we're applying it to the argument of jkl.

        What is the appropriate :guard and do you have to make other modifications to the suggested defun of jkl?

        ——————————

        13: Can jkl be warranted?

        ——————————

        14: Is this a theorem? If not, what theorem does it suggest?

        (implies (nat-listp-listp lst)
                 (nat-listp-listp (jkl lst)))
        ——————————

        See lp-background-review-2-answers for our answers. If your answers basically agree with ours we think you're ready to learn about loop$, so go back to the loop$-primer. Otherwise, we strongly recommend that you read introduction-to-apply$ and then apply$ before reading about loop$.

        (Return to the Table of Contents.)