• Top
    • Documentation
    • Books
    • Boolean-reasoning
    • Projects
    • Debugging
    • Community
    • Std
    • Proof-automation
    • Macro-libraries
    • ACL2
    • Interfacing-tools
    • Hardware-verification
    • Software-verification
      • Kestrel-books
        • Crypto-hdwallet
        • Apt
        • Error-checking
        • Fty-extensions
        • Isar
        • Kestrel-utilities
        • Set
        • C
          • Syntax-for-tools
          • Atc
          • Transformation-tools
            • Simpadd0
            • Proof-generation
              • Xeq-fundef
              • Xeq-expr-cond
              • Xeq-expr-binary
              • Xeq-block-item-list-cons
              • Xeq-stmt-ifelse
              • Xeq-expr-const
              • Gen-param-thms
              • Gen-from-params
              • Xeq-decl-decl
              • Gout
              • Gen-block-item-list-thm
              • Xeq-stmt-while
              • Xeq-stmt-dowhile
              • Gin
              • Xeq-expr-ident
              • Gen-block-item-thm
              • Xeq-stmt-if
              • Xeq-expr-cast
              • Gen-initer-single-thm
              • Gen-init-scope-thm
              • Gen-expr-thm
              • Xeq-expr-unary
              • Gen-decl-thm
              • Gen-stmt-thm
              • Xeq-stmt-return
              • Xeq-stmt-expr
              • Xeq-block-item-decl
              • Xeq-block-item-stmt
              • Xeq-stmt-compound
              • Xeq-initer-single
              • Gen-thm-name
              • Gin-update
              • Gen-var-assertions
              • Tyspecseq-to-type
              • Xeq-block-item-list-empty
                • Gout-no-thm
                • Irr-gout
              • Split-gso
              • Wrap-fn
              • Constant-propagation
              • Specialize
              • Split-fn
              • Split-fn-when
              • Split-all-gso
              • Copy-fn
              • Variables-in-computation-states
              • Rename
              • Utilities
              • Proof-generation-theorems
              • Input-processing
            • Language
            • Representation
            • Insertion-sort
            • Pack
          • Soft
          • Bv
          • Imp-language
          • Ethereum
          • Event-macros
          • Java
          • Riscv
          • Bitcoin
          • Zcash
          • Yul
          • ACL2-programming-language
          • Prime-fields
          • Json
          • Syntheto
          • File-io-light
          • Cryptography
          • Number-theory
          • Axe
          • Lists-light
          • Builtins
          • Solidity
          • Helpers
          • Htclient
          • Typed-lists-light
          • Arithmetic-light
        • X86isa
        • Axe
        • Execloader
      • Math
      • Testing-utilities
    • Proof-generation

    Xeq-block-item-list-empty

    Equality lifting transformation of the empty list of block items.

    Signature
    (xeq-block-item-list-empty gin) → gout
    Arguments
    gin — Guard (ginp gin).
    Returns
    gout — Type (goutp gout).

    This is introduced mainly for uniformity. It actually takes and returns no block item list, because there is only one empty block item list.

    Definitions and Theorems

    Function: xeq-block-item-list-empty

    (defun xeq-block-item-list-empty (gin)
     (declare (xargs :guard (ginp gin)))
     (let ((__function__ 'xeq-block-item-list-empty))
      (declare (ignorable __function__))
      (b*
       (((gin gin) gin)
        (items nil)
        (hints
           '(("Goal" :in-theory '((:e insert)
                                  block-item-list-empty-compustate-vars)
                     :use (block-item-list-empty-congruence))))
        ((mv thm-event thm-name thm-index)
         (gen-block-item-list-thm items items gin.vartys
                                  gin.const-new gin.thm-index hints)))
       (make-gout :events (cons thm-event gin.events)
                  :thm-index thm-index
                  :thm-name thm-name
                  :vartys gin.vartys))))

    Theorem: goutp-of-xeq-block-item-list-empty

    (defthm goutp-of-xeq-block-item-list-empty
      (b* ((gout (xeq-block-item-list-empty gin)))
        (goutp gout))
      :rule-classes :rewrite)

    Theorem: xeq-block-item-list-empty-of-gin-fix-gin

    (defthm xeq-block-item-list-empty-of-gin-fix-gin
      (equal (xeq-block-item-list-empty (gin-fix gin))
             (xeq-block-item-list-empty gin)))

    Theorem: xeq-block-item-list-empty-gin-equiv-congruence-on-gin

    (defthm xeq-block-item-list-empty-gin-equiv-congruence-on-gin
      (implies (gin-equiv gin gin-equiv)
               (equal (xeq-block-item-list-empty gin)
                      (xeq-block-item-list-empty gin-equiv)))
      :rule-classes :congruence)