• Top
  • Documentation
  • Books
  • Recursion-and-induction
  • Boolean-reasoning
    • Ipasir
    • Aignet
      • Base-api
      • Aignet-construction
      • Representation
      • Aignet-copy-init
      • Aignet-simplify-marked-with-tracking
      • Aignet-cnf
      • Aignet-simplify-with-tracking
      • Aignet-complete-copy
      • Aignet-eval
      • Semantics
      • Aignet-transforms
        • Aignet-comb-transforms
          • Fraig
          • Observability-fix
          • Constprop
          • Balance
          • Apply-m-assumption-n-output-output-transform-default
          • Obs-constprop
          • Apply-n-output-comb-transform-default
          • Rewrite
          • Comb-transform
            • Comb-transform-p
            • Fraig-config
            • Comb-transform-fix
            • Rewrite-config
            • Obs-constprop-config
            • Observability-config
            • Constprop-config
            • Comb-transform-equiv
            • Abc-comb-simp-config
            • M-assum-n-output-observability-config
            • Snapshot-config
            • Prune-config
          • Abc-comb-simplify
          • Prune
          • Apply-comb-transform-default
          • Rewrite!
          • M-assumption-n-output-comb-transform->name
          • N-output-comb-transform->name
          • Comb-transform->name
          • N-output-comb-transformlist
          • M-assumption-n-output-comb-transformlist
          • Comb-transformlist
          • Apply-comb-transform
        • Aignet-m-assumption-n-output-transforms
        • Aignet-n-output-comb-transforms
      • Aignet-simplify-marked
      • Aignet-read-aiger
      • Aignet-write-aiger
      • Aignet-abc-interface
      • Utilities
    • Aig
    • Satlink
    • Truth
    • Ubdds
    • Bdd
    • Faig
    • Bed
    • 4v
  • Debugging
  • Projects
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
  • Testing-utilities
  • Math

• Comb-transform

Comb-transform-p

Recognizer for comb-transform.

Signature

(comb-transform-p x) → *

Definitions and Theorems

Function: comb-transform-p

(defun comb-transform-p (x)
       (declare (xargs :guard t))
       (let ((__function__ 'comb-transform-p))
            (declare (ignorable __function__))
            (case (tag x)
                  ((:balance-config) (balance-config-p x))
                  ((:fraig-config) (fraig-config-p x))
                  ((:rewrite-config) (rewrite-config-p x))
                  ((:abc-comb-simp-config)
                   (abc-comb-simp-config-p x))
                  ((:obs-constprop-config)
                   (obs-constprop-config-p x))
                  ((:observability-config)
                   (observability-config-p x))
                  ((:constprop-config)
                   (constprop-config-p x))
                  ((:snapshot-config)
                   (snapshot-config-p x))
                  ((:prune-config) (prune-config-p x))
                  ((:unreachability-config)
                   (unreachability-config-p x))
                  (otherwise (dom-supergates-sweep-config-p x)))))

Theorem: consp-when-comb-transform-p

(defthm consp-when-comb-transform-p
        (implies (comb-transform-p x) (consp x))
        :rule-classes :compound-recognizer)

Theorem: comb-transform-p-when-balance-config-p

(defthm comb-transform-p-when-balance-config-p
        (implies (balance-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-fraig-config-p

(defthm comb-transform-p-when-fraig-config-p
        (implies (fraig-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-rewrite-config-p

(defthm comb-transform-p-when-rewrite-config-p
        (implies (rewrite-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-abc-comb-simp-config-p

(defthm comb-transform-p-when-abc-comb-simp-config-p
        (implies (abc-comb-simp-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-obs-constprop-config-p

(defthm comb-transform-p-when-obs-constprop-config-p
        (implies (obs-constprop-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-observability-config-p

(defthm comb-transform-p-when-observability-config-p
        (implies (observability-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-constprop-config-p

(defthm comb-transform-p-when-constprop-config-p
        (implies (constprop-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-snapshot-config-p

(defthm comb-transform-p-when-snapshot-config-p
        (implies (snapshot-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-prune-config-p

(defthm comb-transform-p-when-prune-config-p
        (implies (prune-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-unreachability-config-p

(defthm comb-transform-p-when-unreachability-config-p
        (implies (unreachability-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-dom-supergates-sweep-config-p

(defthm comb-transform-p-when-dom-supergates-sweep-config-p
        (implies (dom-supergates-sweep-config-p x)
                 (comb-transform-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: balance-config-p-by-tag-when-comb-transform-p

(defthm balance-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :balance-config))
                      (comb-transform-p x))
                 (balance-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: fraig-config-p-by-tag-when-comb-transform-p

(defthm fraig-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :fraig-config))
                      (comb-transform-p x))
                 (fraig-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: rewrite-config-p-by-tag-when-comb-transform-p

(defthm rewrite-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :rewrite-config))
                      (comb-transform-p x))
                 (rewrite-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: abc-comb-simp-config-p-by-tag-when-comb-transform-p

(defthm abc-comb-simp-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :abc-comb-simp-config))
                      (comb-transform-p x))
                 (abc-comb-simp-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: obs-constprop-config-p-by-tag-when-comb-transform-p

(defthm obs-constprop-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :obs-constprop-config))
                      (comb-transform-p x))
                 (obs-constprop-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: observability-config-p-by-tag-when-comb-transform-p

(defthm observability-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :observability-config))
                      (comb-transform-p x))
                 (observability-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: constprop-config-p-by-tag-when-comb-transform-p

(defthm constprop-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :constprop-config))
                      (comb-transform-p x))
                 (constprop-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: snapshot-config-p-by-tag-when-comb-transform-p

(defthm snapshot-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :snapshot-config))
                      (comb-transform-p x))
                 (snapshot-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: prune-config-p-by-tag-when-comb-transform-p

(defthm prune-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :prune-config))
                      (comb-transform-p x))
                 (prune-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: unreachability-config-p-by-tag-when-comb-transform-p

(defthm unreachability-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x) :unreachability-config))
                      (comb-transform-p x))
                 (unreachability-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: dom-supergates-sweep-config-p-by-tag-when-comb-transform-p

(defthm dom-supergates-sweep-config-p-by-tag-when-comb-transform-p
        (implies (and (or (equal (tag x)
                                 :dom-supergates-sweep-config))
                      (comb-transform-p x))
                 (dom-supergates-sweep-config-p x))
        :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: comb-transform-p-when-invalid-tag

(defthm comb-transform-p-when-invalid-tag
        (implies (and (not (equal (tag x) :balance-config))
                      (not (equal (tag x) :fraig-config))
                      (not (equal (tag x) :rewrite-config))
                      (not (equal (tag x) :abc-comb-simp-config))
                      (not (equal (tag x) :obs-constprop-config))
                      (not (equal (tag x) :observability-config))
                      (not (equal (tag x) :constprop-config))
                      (not (equal (tag x) :snapshot-config))
                      (not (equal (tag x) :prune-config))
                      (not (equal (tag x) :unreachability-config))
                      (not (equal (tag x)
                                  :dom-supergates-sweep-config)))
                 (not (comb-transform-p x)))
        :rule-classes ((:rewrite :backchain-limit-lst 0)))

Theorem: tag-when-comb-transform-p-forward

(defthm tag-when-comb-transform-p-forward
        (implies (comb-transform-p x)
                 (or (equal (tag x) :balance-config)
                     (equal (tag x) :fraig-config)
                     (equal (tag x) :rewrite-config)
                     (equal (tag x) :abc-comb-simp-config)
                     (equal (tag x) :obs-constprop-config)
                     (equal (tag x) :observability-config)
                     (equal (tag x) :constprop-config)
                     (equal (tag x) :snapshot-config)
                     (equal (tag x) :prune-config)
                     (equal (tag x) :unreachability-config)
                     (equal (tag x)
                            :dom-supergates-sweep-config)))
        :rule-classes ((:forward-chaining)))