• Top
  • Documentation
  • Books
  • Boolean-reasoning
  • Projects
  • Debugging
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
    • Gl
    • Esim
    • Vl2014
    • Sv
    • Fgl
    • Vwsim
    • Vl
      • Syntax
      • Loader
        • Preprocessor
        • Vl-loadconfig
        • Vl-loadstate
        • Lexer
        • Parser
        • Vl-load-merge-descriptions
        • Vl-find-basename/extension
        • Vl-load-file
        • Vl-loadresult
        • Scope-of-defines
        • Vl-find-file
        • Vl-flush-out-descriptions
        • Vl-description
          • Vl-description-p
          • Vl-sort-descriptions
          • Vl-description-fix
          • Vl-find-description
          • Vl-description-equiv
          • Vl-description->origname
          • Vl-description->name
          • Vl-design-from-descriptions
          • Vl-make-descalist
          • Vl-design-descriptions
          • Vl-fast-filter-descriptions
          • Vl-fast-find-description
          • Vl-descalist
          • Vl-slow-delete-descriptions
        • Vl-read-file
        • Vl-includeskips-report-gather
        • Vl-load-main
        • Extended-characters
        • Vl-load
        • Vl-load-description
        • Vl-descriptions-left-to-load
        • Inject-warnings
        • Vl-preprocess-debug
        • Vl-write-preprocessor-debug-file
        • Vl-read-file-report-gather
        • Vl-load-descriptions
        • Vl-load-files
        • Translate-off
        • Vl-load-read-file-hook
        • Vl-read-file-report
        • Vl-loadstate-pad
        • Vl-load-summary
        • Vl-collect-modules-from-descriptions
        • Vl-loadstate->warnings
        • Vl-iskips-report
        • Vl-descriptionlist
      • Warnings
      • Getting-started
      • Utilities
      • Printer
      • Kit
      • Mlib
      • Transforms
    • X86isa
    • Svl
    • Rtl
  • Software-verification
  • Math
  • Testing-utilities

• Vl-description

Vl-description-p

Recognizer for vl-description.

Signature

(vl-description-p x) → *

Definitions and Theorems

Function: vl-description-p

(defun vl-description-p (x)
  (declare (xargs :guard t))
  (let ((__function__ 'vl-description-p))
    (declare (ignorable __function__))
    (common-lisp::case (tag x)
      ((:vl-module) (vl-module-p x))
      ((:vl-udp) (vl-udp-p x))
      ((:vl-interface) (vl-interface-p x))
      ((:vl-package) (vl-package-p x))
      ((:vl-program) (vl-program-p x))
      ((:vl-class) (vl-class-p x))
      ((:vl-config) (vl-config-p x))
      ((:vl-bind) (vl-bind-p x))
      ((:vl-property) (vl-property-p x))
      ((:vl-sequence) (vl-sequence-p x))
      ((:vl-vardecl) (vl-vardecl-p x))
      ((:vl-taskdecl) (vl-taskdecl-p x))
      ((:vl-fundecl) (vl-fundecl-p x))
      ((:vl-paramdecl) (vl-paramdecl-p x))
      ((:vl-import) (vl-import-p x))
      ((:vl-fwdtypedef) (vl-fwdtypedef-p x))
      ((:vl-typedef) (vl-typedef-p x))
      ((:vl-dpiimport) (vl-dpiimport-p x))
      (otherwise (vl-dpiexport-p x)))))

Theorem: consp-when-vl-description-p

(defthm consp-when-vl-description-p
  (implies (vl-description-p x) (consp x))
  :rule-classes :compound-recognizer)

Theorem: vl-description-p-when-vl-module-p

(defthm vl-description-p-when-vl-module-p
  (implies (vl-module-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-udp-p

(defthm vl-description-p-when-vl-udp-p
  (implies (vl-udp-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-interface-p

(defthm vl-description-p-when-vl-interface-p
  (implies (vl-interface-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-package-p

(defthm vl-description-p-when-vl-package-p
  (implies (vl-package-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-program-p

(defthm vl-description-p-when-vl-program-p
  (implies (vl-program-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-class-p

(defthm vl-description-p-when-vl-class-p
  (implies (vl-class-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-config-p

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

Theorem: vl-description-p-when-vl-bind-p

(defthm vl-description-p-when-vl-bind-p
  (implies (vl-bind-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-property-p

(defthm vl-description-p-when-vl-property-p
  (implies (vl-property-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-sequence-p

(defthm vl-description-p-when-vl-sequence-p
  (implies (vl-sequence-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-vardecl-p

(defthm vl-description-p-when-vl-vardecl-p
  (implies (vl-vardecl-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-taskdecl-p

(defthm vl-description-p-when-vl-taskdecl-p
  (implies (vl-taskdecl-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-fundecl-p

(defthm vl-description-p-when-vl-fundecl-p
  (implies (vl-fundecl-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-paramdecl-p

(defthm vl-description-p-when-vl-paramdecl-p
  (implies (vl-paramdecl-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-import-p

(defthm vl-description-p-when-vl-import-p
  (implies (vl-import-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-fwdtypedef-p

(defthm vl-description-p-when-vl-fwdtypedef-p
  (implies (vl-fwdtypedef-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-typedef-p

(defthm vl-description-p-when-vl-typedef-p
  (implies (vl-typedef-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-dpiimport-p

(defthm vl-description-p-when-vl-dpiimport-p
  (implies (vl-dpiimport-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-vl-dpiexport-p

(defthm vl-description-p-when-vl-dpiexport-p
  (implies (vl-dpiexport-p x)
           (vl-description-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-module-p-by-tag-when-vl-description-p

(defthm vl-module-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-module))
                (vl-description-p x))
           (vl-module-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-udp-p-by-tag-when-vl-description-p

(defthm vl-udp-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-udp))
                (vl-description-p x))
           (vl-udp-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-interface-p-by-tag-when-vl-description-p

(defthm vl-interface-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-interface))
                (vl-description-p x))
           (vl-interface-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-package-p-by-tag-when-vl-description-p

(defthm vl-package-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-package))
                (vl-description-p x))
           (vl-package-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-program-p-by-tag-when-vl-description-p

(defthm vl-program-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-program))
                (vl-description-p x))
           (vl-program-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-class-p-by-tag-when-vl-description-p

(defthm vl-class-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-class))
                (vl-description-p x))
           (vl-class-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-config-p-by-tag-when-vl-description-p

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

Theorem: vl-bind-p-by-tag-when-vl-description-p

(defthm vl-bind-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-bind))
                (vl-description-p x))
           (vl-bind-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-property-p-by-tag-when-vl-description-p

(defthm vl-property-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-property))
                (vl-description-p x))
           (vl-property-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-sequence-p-by-tag-when-vl-description-p

(defthm vl-sequence-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-sequence))
                (vl-description-p x))
           (vl-sequence-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-vardecl-p-by-tag-when-vl-description-p

(defthm vl-vardecl-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-vardecl))
                (vl-description-p x))
           (vl-vardecl-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-taskdecl-p-by-tag-when-vl-description-p

(defthm vl-taskdecl-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-taskdecl))
                (vl-description-p x))
           (vl-taskdecl-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-fundecl-p-by-tag-when-vl-description-p

(defthm vl-fundecl-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-fundecl))
                (vl-description-p x))
           (vl-fundecl-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-paramdecl-p-by-tag-when-vl-description-p

(defthm vl-paramdecl-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-paramdecl))
                (vl-description-p x))
           (vl-paramdecl-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-import-p-by-tag-when-vl-description-p

(defthm vl-import-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-import))
                (vl-description-p x))
           (vl-import-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-fwdtypedef-p-by-tag-when-vl-description-p

(defthm vl-fwdtypedef-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-fwdtypedef))
                (vl-description-p x))
           (vl-fwdtypedef-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-typedef-p-by-tag-when-vl-description-p

(defthm vl-typedef-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-typedef))
                (vl-description-p x))
           (vl-typedef-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-dpiimport-p-by-tag-when-vl-description-p

(defthm vl-dpiimport-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-dpiimport))
                (vl-description-p x))
           (vl-dpiimport-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-dpiexport-p-by-tag-when-vl-description-p

(defthm vl-dpiexport-p-by-tag-when-vl-description-p
  (implies (and (or (equal (tag x) :vl-dpiexport))
                (vl-description-p x))
           (vl-dpiexport-p x))
  :rule-classes ((:rewrite :backchain-limit-lst 1)))

Theorem: vl-description-p-when-invalid-tag

(defthm vl-description-p-when-invalid-tag
  (implies (and (not (equal (tag x) :vl-module))
                (not (equal (tag x) :vl-udp))
                (not (equal (tag x) :vl-interface))
                (not (equal (tag x) :vl-package))
                (not (equal (tag x) :vl-program))
                (not (equal (tag x) :vl-class))
                (not (equal (tag x) :vl-config))
                (not (equal (tag x) :vl-bind))
                (not (equal (tag x) :vl-property))
                (not (equal (tag x) :vl-sequence))
                (not (equal (tag x) :vl-vardecl))
                (not (equal (tag x) :vl-taskdecl))
                (not (equal (tag x) :vl-fundecl))
                (not (equal (tag x) :vl-paramdecl))
                (not (equal (tag x) :vl-import))
                (not (equal (tag x) :vl-fwdtypedef))
                (not (equal (tag x) :vl-typedef))
                (not (equal (tag x) :vl-dpiimport))
                (not (equal (tag x) :vl-dpiexport)))
           (not (vl-description-p x)))
  :rule-classes ((:rewrite :backchain-limit-lst 0)))

Theorem: tag-when-vl-description-p-forward

(defthm tag-when-vl-description-p-forward
  (implies (vl-description-p x)
           (or (equal (tag x) :vl-module)
               (equal (tag x) :vl-udp)
               (equal (tag x) :vl-interface)
               (equal (tag x) :vl-package)
               (equal (tag x) :vl-program)
               (equal (tag x) :vl-class)
               (equal (tag x) :vl-config)
               (equal (tag x) :vl-bind)
               (equal (tag x) :vl-property)
               (equal (tag x) :vl-sequence)
               (equal (tag x) :vl-vardecl)
               (equal (tag x) :vl-taskdecl)
               (equal (tag x) :vl-fundecl)
               (equal (tag x) :vl-paramdecl)
               (equal (tag x) :vl-import)
               (equal (tag x) :vl-fwdtypedef)
               (equal (tag x) :vl-typedef)
               (equal (tag x) :vl-dpiimport)
               (equal (tag x) :vl-dpiexport)))
  :rule-classes ((:forward-chaining)))