• Top
    • Documentation
    • Books
    • Recursion-and-induction
    • Boolean-reasoning
    • Debugging
    • Projects
    • Std
    • Proof-automation
    • Macro-libraries
    • ACL2
    • Interfacing-tools
    • Hardware-verification
    • Software-verification
      • Kestrel-books
        • Crypto-hdwallet
        • Error-checking
        • Apt
        • Abnf
        • Fty-extensions
        • Isar
        • Kestrel-utilities
        • Prime-field-constraint-systems
          • Proof-support
            • Exec-proof-tree-when-constraint-equal
            • Constraint-satp-of-equal
            • R1cs-subset
            • Semantics
            • Abstract-syntax
            • Well-formedness
            • Abstract-syntax-operations
            • R1cs-bridge
            • Concrete-syntax
            • Prime-field-library-extensions
            • R1cs-library-extensions
          • Soft
          • Bv
          • Imp-language
          • Event-macros
          • Bitcoin
          • Ethereum
          • Yul
          • Zcash
          • ACL2-programming-language
          • Prime-fields
          • Java
          • C
          • Syntheto
          • Number-theory
          • Cryptography
          • Lists-light
          • File-io-light
          • Json
          • Built-ins
          • Solidity
          • Axe
          • Std-extensions
          • Htclient
          • Typed-lists-light
          • Arithmetic-light
        • X86isa
        • Execloader
        • Axe
      • Testing-utilities
      • Math
    • Proof-support

    Constraint-satp-of-equal

    Proof rule for equality constraints.

    This says that the satisfaction of an equality constraint reduces to the two expressions being equal and non-erroneous.

    This rule lets us dispense with the existentially quantified proof tree for the common case of equality constraints.

    Definitions and Theorems

    Theorem: constraint-satp-of-equal

    (defthm constraint-satp-of-equal
            (implies (and (assignment-for-prime-p asg p)
                          (constraint-case constr :equal))
                     (b* ((left (constraint-equal->left constr))
                          (right (constraint-equal->right constr)))
                         (iff (constraint-satp asg constr defs p)
                              (and (equal (eval-expr asg left p)
                                          (eval-expr asg right p))
                                   (eval-expr asg left p))))))