• Top
  • Documentation
  • Books
  • Boolean-reasoning
    • Ipasir
    • Aignet
    • Aig
    • Satlink
    • Truth
    • Ubdds
    • Bdd
    • Faig
      • Faig-constructors
        • T-aig-ite*
        • F-aig-ite*
        • T-aig-ite
        • F-aig-ite
        • T-aig-tristate
        • F-aig-zif
        • T-aig-xor
        • T-aig-or
        • T-aig-iff
        • T-aig-and
        • F-aig-and
        • F-aig-xor
        • F-aig-or
        • F-aig-iff
        • F-aig-res
        • F-aig-unfloat
        • T-aig-not
        • F-aig-pullup
        • F-aig-not
        • T-aig-xdet
        • F-aig-xdet
      • Faig-onoff-equiv
      • Faig-purebool-p
      • Faig-alist-equiv
      • Faig-equiv
      • Faig-eval
      • Faig-restrict
      • Faig-fix
      • Faig-partial-eval
      • Faig-compose
      • Faig-compose-alist
      • Patbind-faig
      • Faig-constants
    • Bed
    • 4v
  • Projects
  • Debugging
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
  • Math
  • Testing-utilities

• Faig-constructors

T-aig-ite*

(t-aig-ite* c a b) constructs a (more conservative) FAIG representing (if c a b), assuming these input FAIGs cannot evaluate to Z.

Signature

(t-aig-ite* c a b) → *

This is a more-conservative version of t-aig-ite that emits X in the case that c is unknown, even when a = b. See 4v-ite for discussion related to this issue.

Definitions and Theorems

Function: t-aig-ite*

(defun t-aig-ite* (c a b)
  (declare (xargs :guard t))
  (let ((__function__ 't-aig-ite*))
    (declare (ignorable __function__))
    (b* (((faig a1 a0) a)
         ((faig b1 b0) b)
         ((faig c1 c0) c)
         (x (aig-and c1 c0)))
      (cons (aig-or x
                    (aig-or (aig-and c1 a1)
                            (aig-and c0 b1)))
            (aig-or x
                    (aig-or (aig-and c1 a0)
                            (aig-and c0 b0)))))))

Theorem: faig-eval-of-t-aig-ite*

(defthm faig-eval-of-t-aig-ite*
  (equal (faig-eval (t-aig-ite* c a b) env)
         (t-aig-ite* (faig-eval c env)
                     (faig-eval a env)
                     (faig-eval b env))))

Theorem: faig-fix-equiv-implies-equal-t-aig-ite*-1

(defthm faig-fix-equiv-implies-equal-t-aig-ite*-1
  (implies (faig-fix-equiv c c-equiv)
           (equal (t-aig-ite* c a b)
                  (t-aig-ite* c-equiv a b)))
  :rule-classes (:congruence))

Theorem: faig-fix-equiv-implies-equal-t-aig-ite*-2

(defthm faig-fix-equiv-implies-equal-t-aig-ite*-2
  (implies (faig-fix-equiv a a-equiv)
           (equal (t-aig-ite* c a b)
                  (t-aig-ite* c a-equiv b)))
  :rule-classes (:congruence))

Theorem: faig-fix-equiv-implies-equal-t-aig-ite*-3

(defthm faig-fix-equiv-implies-equal-t-aig-ite*-3
  (implies (faig-fix-equiv b b-equiv)
           (equal (t-aig-ite* c a b)
                  (t-aig-ite* c a b-equiv)))
  :rule-classes (:congruence))

Theorem: faig-equiv-implies-faig-equiv-t-aig-ite*-3

(defthm faig-equiv-implies-faig-equiv-t-aig-ite*-3
  (implies (faig-equiv b b-equiv)
           (faig-equiv (t-aig-ite* c a b)
                       (t-aig-ite* c a b-equiv)))
  :rule-classes (:congruence))

Theorem: faig-equiv-implies-faig-equiv-t-aig-ite*-2

(defthm faig-equiv-implies-faig-equiv-t-aig-ite*-2
  (implies (faig-equiv a a-equiv)
           (faig-equiv (t-aig-ite* c a b)
                       (t-aig-ite* c a-equiv b)))
  :rule-classes (:congruence))

Theorem: faig-equiv-implies-faig-equiv-t-aig-ite*-1

(defthm faig-equiv-implies-faig-equiv-t-aig-ite*-1
  (implies (faig-equiv c c-equiv)
           (faig-equiv (t-aig-ite* c a b)
                       (t-aig-ite* c-equiv a b)))
  :rule-classes (:congruence))