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

• 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)))