• Top
    • Documentation
    • Books
    • Recursion-and-induction
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
    • Proof-automation
      • Gl
        • Term-level-reasoning
        • Glmc
        • Other-resources
        • Optimization
        • Reference
          • Def-gl-thm
          • Shape-specs
          • Symbolic-objects
          • Gl-aside
          • Def-gl-param-thm
          • Symbolic-arithmetic
          • Bfr
          • Def-gl-boolean-constraint
          • Gl-mbe
          • Bvec
          • Flex-bindings
          • Auto-bindings
          • Gl-interp
          • Gl-set-uninterpreted
          • Def-gl-clause-processor
          • Def-glcp-ctrex-rewrite
          • ACL2::always-equal
            • Gl-hint
            • Def-gl-rewrite
            • Def-gl-branch-merge
            • Gl-force-check
            • Gl-concretize
            • Gl-assert
            • Gl-param-thm
            • Gl-simplify-satlink-mode
            • Gl-satlink-mode
            • Gl-bdd-mode
            • Gl-aig-bddify-mode
            • Gl-fraig-satlink-mode
          • Debugging
          • Basic-tutorial
        • Witness-cp
        • Ccg
        • Install-not-normalized
        • Rewrite$
        • Removable-runes
        • Efficiency
        • Rewrite-bounds
        • Bash
        • Def-dag-measure
        • Fgl
        • Bdd
        • Remove-hyps
        • Contextual-rewriting
        • Simp
        • Rewrite$-hyps
        • Bash-term-to-dnf
        • Use-trivial-ancestors-check
        • Minimal-runes
        • Clause-processor-tools
        • Fn-is-body
        • Without-subsumption
        • Rewrite-equiv-hint
        • Def-bounds
        • Rewrite$-context
        • Try-gl-concls
        • Hint-utils
      • Macro-libraries
      • ACL2
      • Interfacing-tools
      • Hardware-verification
      • Software-verification
      • Testing-utilities
      • Math
    • Reference

    ACL2::always-equal

    Alias for equal that has a special meaning in gl-bdd-mode.

    Signature
    (acl2::always-equal x y) → *

    Logically this is just equal, but gl treats always-equal in a special way.

    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. This stops you from seeing any counterexamples, even though GL knows that the two objects aren't equal.

    To work around this, you may restate your theorem using always-equal instead of equal as the final comparison. 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.

    Note that there is not really any reason to use always-equal if you are using an AIG-based GL mode, such as gl-satlink-mode.

    Definitions and Theorems

    Function: always-equal

    (defun acl2::always-equal (x y)
      (declare (xargs :guard t))
      (let ((__function__ 'acl2::always-equal))
        (declare (ignorable __function__))
        (equal x y)))