• Top
    • Documentation
    • Books
    • Recursion-and-induction
    • Boolean-reasoning
      • Ipasir
        • Ipasir$a
          • Ipasir$a-p
          • Ipasir$a-fix
          • Ipasir-set-limit$a
          • Ipasir-add-lit$a
          • Ipasir-assume$a
          • Ipasir-init$a
          • Make-ipasir$a
          • Ipasir-finalize-clause$a
          • Ipasir-reinit$a
          • Ipasir$a-equiv
          • Ipasir-input$a
          • Ipasir-val$a
            • Ipasir-release$a
            • Ipasir$a->solved-assumption
            • Ipasir$a->new-clause
            • Ipasir$a->callback-count
            • Ipasir$a->assumption
            • Ipasir-failed$a
            • Change-ipasir$a
            • Ipasir$a->solution
            • Ipasir$a->formula
            • Ipasir$a->status
            • Ipasir$a->history
            • Ipasir-callback-count$a
            • Ipasir-solved-assumption$a
            • Ipasir-some-history$a
            • Ipasir-get-status$a
            • Ipasir-get-assumption$a
            • Ipasir-empty-new-clause$a
            • Create-ipasir$a
            • Ipasir-solve$a
          • Building-an-ipasir-solver-library
          • Ipasir-formula
          • Ipasir-bump-activity-vars$a
          • Ipasir-set$a
          • Ipasir-bump-activity-vars$c
          • Ipasir-get$a
          • Ipasir-set-limit$c
          • Ipasir-set$c
          • Ipasir-failed$c
          • Ipasir-assume$c
          • Ipasir-add-lit$c
          • Ipasir-val$c
          • With-local-ipasir
          • Ipasir-solve$c
          • Ipasir-reinit$c
          • Ipasir-init$c
          • Ipasir-finalize-clause$c
          • Ipasir-some-history$c
          • Ipasir-solved-assumption$c
          • Ipasir-release$c
          • Ipasir-input$c
          • Ipasir-get$c
          • Ipasir-get-status$c
          • Ipasir-get-curr-stats$c
          • Ipasir-get-assumption$c
          • Ipasir-empty-new-clause$c
          • Ipasir-callback-count$c
          • Ipasir-val
          • Ipasir-solve
          • Ipasir-set-limit
          • Ipasir-reinit
          • Ipasir-failed
          • Ipasir-callback-count
          • Ipasir-release
          • Ipasir-input
          • Ipasir-init
          • Ipasir-finalize-clause
          • Ipasir-assume
          • Ipasir-add-lit
        • Aignet
        • Aig
        • Satlink
        • Truth
        • Ubdds
        • Bdd
        • Faig
        • Bed
        • 4v
      • Projects
      • Debugging
      • Std
      • Proof-automation
      • Macro-libraries
      • ACL2
      • Interfacing-tools
      • Hardware-verification
      • Software-verification
      • Testing-utilities
      • Math
    • Ipasir$a

    Ipasir-val$a

    Logic form of ipasir-val. See ipasir for usage.

    Signature
    (ipasir-val$a solver lit) → val
    Arguments
    solver — Guard (ipasir$a-p solver).
    lit — Guard (litp lit).
    Returns
    val — Type (or (bitp val) (not val)).

    Definitions and Theorems

    Function: ipasir-val$a

    (defun
         ipasir-val$a (solver lit)
         (declare (xargs :guard (and (ipasir$a-p solver) (litp lit))))
         (declare (xargs :guard (eq (ipasir-get-status$a solver) :sat)))
         (let ((__function__ 'ipasir-val$a))
              (declare (ignorable __function__))
              (b* (((ipasir$a solver))
                   (lit (lit-fix lit)))
                  (lit-cube-val lit solver.solution))))

    Theorem: return-type-of-ipasir-val$a

    (defthm return-type-of-ipasir-val$a
            (b* ((val (ipasir-val$a solver lit)))
                (or (bitp val) (not val)))
            :rule-classes :type-prescription)

    Theorem: ipasir-val$a-of-ipasir$a-fix-solver

    (defthm ipasir-val$a-of-ipasir$a-fix-solver
            (equal (ipasir-val$a (ipasir$a-fix solver) lit)
                   (ipasir-val$a solver lit)))

    Theorem: ipasir-val$a-ipasir$a-equiv-congruence-on-solver

    (defthm ipasir-val$a-ipasir$a-equiv-congruence-on-solver
            (implies (ipasir$a-equiv solver solver-equiv)
                     (equal (ipasir-val$a solver lit)
                            (ipasir-val$a solver-equiv lit)))
            :rule-classes :congruence)

    Theorem: ipasir-val$a-of-lit-fix-lit

    (defthm ipasir-val$a-of-lit-fix-lit
            (equal (ipasir-val$a solver (lit-fix lit))
                   (ipasir-val$a solver lit)))

    Theorem: ipasir-val$a-lit-equiv-congruence-on-lit

    (defthm ipasir-val$a-lit-equiv-congruence-on-lit
            (implies (lit-equiv lit lit-equiv)
                     (equal (ipasir-val$a solver lit)
                            (ipasir-val$a solver lit-equiv)))
            :rule-classes :congruence)