• Top
    • Documentation
    • Books
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
    • Proof-automation
    • Macro-libraries
    • ACL2
      • Theories
      • Rule-classes
      • Proof-builder
      • Recursion-and-induction
      • Hons-and-memoization
      • Events
      • Parallelism
      • History
      • Programming
      • Operational-semantics
      • Real
      • Start-here
      • Debugging
      • Miscellaneous
        • Term
          • Lambda
          • Pseudo-termp
          • Term-order
          • Pseudo-term-listp
          • Guard-holders
          • Termp
          • Termify
            • L<
            • Kwote
            • Kwote-lst
          • Ld
          • Hints
          • Type-set
          • Ordinals
          • Clause
          • ACL2-customization
          • With-prover-step-limit
          • Set-prover-step-limit
          • With-prover-time-limit
          • Local-incompatibility
          • Set-case-split-limitations
          • Subversive-recursions
          • Specious-simplification
          • Defsum
          • Gcl
          • Oracle-timelimit
          • Thm
          • Defopener
          • Case-split-limitations
          • Set-gc-strategy
          • Default-defun-mode
          • Top-level
          • Reader
          • Ttags-seen
          • Adviser
          • Ttree
          • Abort-soft
          • Defsums
          • Gc$
          • With-timeout
          • Coi-debug::fail
          • Expander
          • Gc-strategy
          • Coi-debug::assert
          • Sin-cos
          • Def::doc
          • Syntax
          • Subversive-inductions
        • Output-controls
        • Macros
        • Interfacing-tools
      • Interfacing-tools
      • Hardware-verification
      • Software-verification
      • Math
      • Testing-utilities
    • Term

    Termify

    the process of converting a clause to a term

    The ACL2 prover represents its goals and subgoals as clauses, e.g., lists of terms treated as disjunctions. The individual elements of a clause are called literals. For example a goal printed as (IMPLIES (AND p q) r) is internally represented as the 3-literal clause ((NOT p) (NOT q) r). A clause containing just one literal is called a unit clause.

    To termify a clause containing multiple literals, we convert the clause to a unit clause using IF to express the disjunction. For example, the 3-literal clause ((NOT p) (NOT q) r) is propositionally equivalent to the term (IF (NOT P) 'T (IF (NOT Q) 'T R)). By embedding that IF-term in a singleton list we obtain a unit clause equivalent to the original 3-literal clause.

    Applying an induction scheme to a clause containing multiple literals can produce an exponential number of cases. This does not happen if the clause is a unit clause. So the ACL2 induction mechanism sometimes termifies its goal clause before applying the induction scheme to shift the case-analysis burden to the rest of the prover.