• 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
        • Soft
        • Bv
        • Imp-language
        • Ethereum
        • Event-macros
        • Java
          • Atj
          • Aij
          • Language
            • Syntax
              • Grammar
                • Cst-statement-without-trailing-substatement-conc?
                • Abnf-tree-with-root-p
                • *grammar*
                • Cst-statement-expression-conc?
                • Cst-literal-conc?
                • Cst-statement-no-short-if-conc?
                • Cst-statement-conc?
                • Cst-import-declaration-conc?
                • Cst-class-body-declaration-conc?
                • Cst-postfix-expression-conc?
                • Cst-integer-literal-conc?
                • Cst-token-conc?
                • Cst-unann-reference-type-conc?
                • Cst-text-block-character-conc?
                • Cst-local-class-or-interface-declaration-conc?
                • Cst-compilation-unit-conc?
                • Cst-class-declaration-conc?
                • Cst-block-statement-conc?
                • Cst-unann-class-or-interface-type-conc?
                • Cst-reference-type-conc?
                • Cst-left-hand-side-conc?
                • Cst-element-value-conc?
                • Cst-input-element-conc?
                • Cst-for-statement-no-short-if-conc?
                • Cst-array-creation-expression-conc?
                • Cst-annotation-conc?
                • Cst-unicode-input-character-conc?
                • Cst-record-body-declaration-conc?
                • Cst-floating-point-literal-conc?
                • Cst-class-or-interface-type-conc?
                • Cst-variable-initializer-conc?
                • Cst-interface-declaration-conc?
                • Cst-assignment-expression-conc?
                • Cst-variable-access-conc?
                • Cst-string-character-conc?
                • Cst-statement-without-trailing-substatement-conc9-rep-elem
                • Cst-statement-without-trailing-substatement-conc8-rep-elem
                • Cst-statement-without-trailing-substatement-conc7-rep-elem
                • Cst-statement-without-trailing-substatement-conc6-rep-elem
                • Cst-statement-without-trailing-substatement-conc5-rep-elem
                • Cst-statement-without-trailing-substatement-conc4-rep-elem
                • Cst-statement-without-trailing-substatement-conc3-rep-elem
                • Cst-statement-without-trailing-substatement-conc2-rep-elem
                • Cst-statement-without-trailing-substatement-conc13-rep-elem
                • Cst-statement-without-trailing-substatement-conc12-rep-elem
                • Cst-statement-without-trailing-substatement-conc11-rep-elem
                • Cst-statement-without-trailing-substatement-conc10-rep-elem
                • Cst-statement-without-trailing-substatement-conc1-rep-elem
                • Cst-not-star-not-slash-conc?
                • Cst-list-list-conc-matchp$
                • Cst-component-pattern-conc?
                • Abnf-tree-list-with-root-p
                  • Abnf-tree-list-with-root-p-basics
                • Cst-unqualified-class-instance-creation-expression-conc
                • Cst-type-argument-conc?
                • Cst-statement-without-trailing-substatement-conc9-rep
                • Cst-statement-without-trailing-substatement-conc8-rep
                • Cst-statement-without-trailing-substatement-conc7-rep
                • Cst-statement-without-trailing-substatement-conc6-rep
                • Cst-statement-without-trailing-substatement-conc5-rep
                • Cst-statement-without-trailing-substatement-conc4-rep
                • Cst-statement-without-trailing-substatement-conc3-rep
                • Cst-statement-without-trailing-substatement-conc2-rep
                • Cst-statement-without-trailing-substatement-conc13-rep
                • Cst-statement-without-trailing-substatement-conc12-rep
                • Cst-statement-without-trailing-substatement-conc11-rep
                • Cst-statement-without-trailing-substatement-conc10-rep
                • Cst-statement-without-trailing-substatement-conc1-rep
                • Cst-numeric-type-conc?
                • Cst-local-class-or-interface-declaration-conc2-rep-elem
                • Cst-local-class-or-interface-declaration-conc1-rep-elem
                • Cst-list-list-alt-matchp$
                • Cst-for-statement-conc?
                • Cst-exception-type-conc?
                • Cst-unann-type-conc?
                • Cst-statement-without-trailing-substatement-conc9
                • Cst-statement-without-trailing-substatement-conc8
                • Cst-statement-without-trailing-substatement-conc7
                • Cst-statement-without-trailing-substatement-conc5
                • Cst-statement-without-trailing-substatement-conc4
                • Cst-statement-without-trailing-substatement-conc3
                • Cst-statement-without-trailing-substatement-conc2
                • Cst-statement-without-trailing-substatement-conc13
                • Cst-statement-without-trailing-substatement-conc12
                • Cst-statement-without-trailing-substatement-conc11
                • Cst-statement-without-trailing-substatement-conc10
                • Cst-local-class-or-interface-declaration-conc2-rep
                • Cst-local-class-or-interface-declaration-conc1-rep
                • Cst-lambda-body-conc?
                • Cst-for-init-conc?
                • Cst-expression-conc?
                • Cst-unann-class-or-interface-type-conc2-rep-elem
                • Cst-unann-class-or-interface-type-conc1-rep-elem
                • Cst-statement-without-trailing-substatement-conc6
                • Cst-statement-without-trailing-substatement-conc1
                • Cst-resource-conc?
                • Cst-primary-conc?
                • Cst-pattern-conc?
                • Cst-not-star-conc?
                • Cst-local-class-or-interface-declaration-conc2
                • Cst-local-class-or-interface-declaration-conc1
                • Cst-list-rep-matchp$
                • Cst-list-elem-matchp$
                • Cst-keyword-conc?
                • Cst-comment-conc?
                • Cst-class-or-interface-type-to-instantiate-conc
                • Cst-annotation-interface-element-declaration-conc
                • Cst-unqualified-method-identifier-conc-rep-elem
                • Cst-unicode-input-character-conc2-rep-elem
                • Cst-unicode-input-character-conc1-rep-elem
                • Cst-unann-class-or-interface-type-conc2-rep
                • Cst-unann-class-or-interface-type-conc2
                • Cst-unann-class-or-interface-type-conc1-rep
                • Cst-unann-class-or-interface-type-conc1
                • Cst-type-conc?
                • Cst-static-import-on-demand-declaration-conc
                • Cst-statement-no-short-if-conc5-rep-elem
                • Cst-statement-no-short-if-conc4-rep-elem
                • Cst-statement-no-short-if-conc3-rep-elem
                • Cst-statement-no-short-if-conc2-rep-elem
                • Cst-statement-no-short-if-conc1-rep-elem
                • Cst-record-body-declaration-conc2-rep-elem
                • Cst-record-body-declaration-conc1-rep-elem
                • Cst-local-variable-declaration-statement-conc
                • Cst-interface-declaration-conc2-rep-elem
                • Cst-interface-declaration-conc1-rep-elem
                • Cst-if-then-else-statement-no-short-if-conc
                • Cst-hexadecimal-floating-point-literal-conc
                • Cst-for-statement-no-short-if-conc2-rep-elem
                • Cst-for-statement-no-short-if-conc2-rep
                • Cst-for-statement-no-short-if-conc1-rep-elem
                • Cst-for-statement-no-short-if-conc1-rep
                • Cst-floating-point-literal-conc2-rep-elem
                • Cst-floating-point-literal-conc1-rep-elem
                • Cst-enhanced-for-statement-no-short-if-conc
                • Cst-class-or-interface-type-conc2-rep-elem
                • Cst-class-or-interface-type-conc1-rep-elem
                • Cst-class-body-declaration-conc4-rep-elem
                • Cst-class-body-declaration-conc3-rep-elem
                • Cst-class-body-declaration-conc2-rep-elem
                • Cst-class-body-declaration-conc1-rep-elem
                • Cst-array-creation-expression-conc2-rep-elem
                • Cst-array-creation-expression-conc2-rep
                • Cst-array-creation-expression-conc1-rep-elem
                • Cst-array-creation-expression-conc1-rep
                • Cst-variable-initializer-conc2-rep-elem
                • Cst-variable-initializer-conc1-rep-elem
                • Cst-variable-arity-record-component-conc
                • Cst-unqualified-method-identifier-conc-rep
                • Cst-unicode-input-character-conc2-rep
                • Cst-unicode-input-character-conc1-rep
                • Cst-unann-reference-type-conc3-rep-elem
                • Cst-unann-reference-type-conc2-rep-elem
                • Cst-unann-reference-type-conc1-rep-elem
                • Cst-unann-reference-type-conc1-rep
                • Cst-type-import-on-demand-declaration-conc
                • Cst-text-block-character-conc3-rep-elem
                • Cst-text-block-character-conc2-rep-elem
                • Cst-text-block-character-conc1-rep-elem
                • Cst-statement-no-short-if-conc5-rep
                • Cst-statement-no-short-if-conc4-rep
                • Cst-statement-no-short-if-conc3-rep
                • Cst-statement-no-short-if-conc2-rep
                • Cst-statement-no-short-if-conc1-rep
                • Cst-statement-expression-conc7-rep-elem
                • Cst-statement-expression-conc7-rep
                • Cst-statement-expression-conc6-rep-elem
                • Cst-statement-expression-conc5-rep-elem
                • Cst-statement-expression-conc5-rep
                • Cst-statement-expression-conc4-rep-elem
                • Cst-statement-expression-conc4-rep
                • Cst-statement-expression-conc3-rep-elem
                • Cst-statement-expression-conc2-rep-elem
                • Cst-statement-expression-conc1-rep-elem
                • Cst-single-type-import-declaration-conc
                • Cst-single-static-import-declaration-conc
                • Cst-single-module-import-declaration-conc
                • Cst-record-component-modifier-conc-rep-elem
                • Cst-record-body-declaration-conc2-rep
                • Cst-record-body-declaration-conc1-rep
                • Cst-postfix-expression-conc4-rep-elem
                • Cst-postfix-expression-conc3-rep-elem
                • Cst-normal-interface-declaration-conc
                • Cst-labeled-statement-no-short-if-conc
                • Cst-interface-declaration-conc2-rep
                • Cst-interface-declaration-conc1-rep
                • Cst-import-declaration-conc5-rep-elem
                • Cst-import-declaration-conc4-rep-elem
                • Cst-import-declaration-conc3-rep-elem
                • Cst-import-declaration-conc2-rep-elem
                • Cst-import-declaration-conc1-rep-elem
                • Cst-for-statement-no-short-if-conc2
                • Cst-for-statement-no-short-if-conc1
                • Cst-floating-point-literal-conc2-rep
                • Cst-floating-point-literal-conc1-rep
                • Cst-element-value-array-initializer-conc
                • Cst-compact-constructor-declaration-conc
                • Cst-class-or-interface-type-conc2-rep
                • Cst-class-or-interface-type-conc1-rep
                • Cst-class-body-declaration-conc4-rep
                • Cst-class-body-declaration-conc3-rep
                • Cst-class-body-declaration-conc2-rep
                • Cst-class-body-declaration-conc1-rep
                • Cst-binary-exponent-indicator-conc-rep-elem
                • Cst-binary-digits-and-underscores-conc
                • Cst-basic-for-statement-no-short-if-conc
                • Cst-assignment-expression-conc2-rep-elem
                • Cst-assignment-expression-conc2-rep
                • Cst-assignment-expression-conc1-rep-elem
                • Cst-assignment-expression-conc1-rep
                • Cst-array-creation-expression-conc2
                • Cst-array-creation-expression-conc1
                • Cst-annotation-interface-declaration-conc
                • Cst-while-statement-no-short-if-conc
                • Cst-variable-initializer-list-conc
                • Cst-variable-initializer-conc2-rep
                • Cst-variable-initializer-conc2
                • Cst-variable-initializer-conc1-rep
                • Cst-variable-initializer-conc1
                • Cst-variable-access-conc2-rep-elem
                • Cst-variable-access-conc1-rep-elem
                • Cst-unqualified-method-identifier-conc
                • Cst-unicode-input-character-conc2
                • Cst-unicode-input-character-conc1
                • Cst-unann-reference-type-conc3-rep
                • Cst-unann-reference-type-conc3
                • Cst-unann-reference-type-conc2-rep
                • Cst-unann-reference-type-conc2
                • Cst-unann-reference-type-conc1
                • Cst-unann-interface-type-conc-rep-elem
                • Cst-type-parameter-modifier-conc-rep-elem
                • Cst-type-parameter-modifier-conc-rep
                • Cst-type-argument-conc2-rep-elem
                • Cst-type-argument-conc1-rep-elem
                • Cst-try-with-resources-statement-conc
                • Cst-text-block-white-space-conc-rep-elem
                • Cst-text-block-white-space-conc-rep
                • Cst-text-block-character-conc3-rep
                • Cst-text-block-character-conc3
                • Cst-text-block-character-conc2-rep
                • Cst-text-block-character-conc2
                • Cst-text-block-character-conc1-rep
                • Cst-text-block-character-conc1
                • Cst-switch-block-statement-group-conc
                • Cst-string-character-conc2-rep-elem
                • Cst-string-character-conc2-rep
                • Cst-string-character-conc1-rep-elem
                • Cst-string-character-conc1-rep
                • Cst-statement-no-short-if-conc5
                • Cst-statement-no-short-if-conc4
                • Cst-statement-no-short-if-conc3
                • Cst-statement-no-short-if-conc2
                • Cst-statement-no-short-if-conc1
                • Cst-statement-expression-list-conc
                • Cst-statement-expression-conc7
                • Cst-statement-expression-conc6-rep
                • Cst-statement-expression-conc6
                • Cst-statement-expression-conc5
                • Cst-statement-expression-conc4
                • Cst-statement-expression-conc3-rep
                • Cst-statement-expression-conc3
                • Cst-statement-expression-conc2-rep
                • Cst-statement-expression-conc2
                • Cst-statement-expression-conc1-rep
                • Cst-statement-expression-conc1
                • Cst-reference-type-conc3-rep-elem
                • Cst-reference-type-conc2-rep-elem
                • Cst-reference-type-conc1-rep-elem
                • Cst-record-component-modifier-conc-rep
                • Cst-record-body-declaration-conc2
                • Cst-record-body-declaration-conc1
                • Cst-postfix-expression-conc4-rep
                • Cst-postfix-expression-conc3-rep
                • Cst-postfix-expression-conc2-rep-elem
                • Cst-postfix-expression-conc2-rep
                • Cst-postfix-expression-conc1-rep-elem
                • Cst-postfix-expression-conc1-rep
                • Cst-ordinary-compilation-unit-conc
                • Cst-octal-digits-and-underscores-conc
                • Cst-not-star-not-slash-conc2-rep-elem
                • Cst-not-star-not-slash-conc2-rep
                • Cst-not-star-not-slash-conc1-rep-elem
                • Cst-not-star-not-slash-conc1-rep
                • Cst-normal-class-declaration-conc
                • Cst-matchp$
                • Cst-local-variable-declaration-conc
                • Cst-left-hand-side-conc3-rep-elem
                • Cst-left-hand-side-conc2-rep-elem
                • Cst-left-hand-side-conc1-rep-elem
                • Cst-java-letter-or-digit-conc-rep-elem
                • Cst-interface-method-declaration-conc
                • Cst-interface-declaration-conc2
                • Cst-interface-declaration-conc1
                • Cst-integer-literal-conc4-rep-elem
                • Cst-integer-literal-conc4-rep
                • Cst-integer-literal-conc3-rep-elem
                • Cst-integer-literal-conc3-rep
                • Cst-integer-literal-conc2-rep-elem
                • Cst-integer-literal-conc1-rep-elem
                • Cst-instance-initializer-conc-rep-elem
                • Cst-input-element-conc3-rep-elem
                • Cst-input-element-conc2-rep-elem
                • Cst-input-element-conc1-rep-elem
                • Cst-import-declaration-conc5-rep
                • Cst-import-declaration-conc4-rep
                • Cst-import-declaration-conc4
                • Cst-import-declaration-conc3-rep
                • Cst-import-declaration-conc2-rep
                • Cst-import-declaration-conc1-rep
                • Cst-hex-digits-and-underscores-conc
                • Cst-for-statement-conc2-rep-elem
                • Cst-for-statement-conc1-rep-elem
                • Cst-floating-point-literal-conc2
                • Cst-floating-point-literal-conc1
                • Cst-exception-type-conc2-rep-elem
                • Cst-exception-type-conc1-rep-elem
                • Cst-enum-constant-modifier-conc-rep-elem
                • Cst-enum-constant-modifier-conc-rep
                • Cst-element-value-conc3-rep-elem
                • Cst-element-value-conc2-rep-elem
                • Cst-element-value-conc1-rep-elem
                • Cst-component-pattern-conc2-rep-elem
                • Cst-component-pattern-conc2-rep
                • Cst-component-pattern-conc1-rep-elem
                • Cst-component-pattern-conc1-rep
                • Cst-compilation-unit-conc3-rep-elem
                • Cst-compilation-unit-conc3-rep
                • Cst-compilation-unit-conc2-rep-elem
                • Cst-compilation-unit-conc2-rep
                • Cst-compilation-unit-conc1-rep-elem
                • Cst-compilation-unit-conc1-rep
                • Cst-compact-compilation-unit-conc
                • Cst-class-or-interface-type-conc2
                • Cst-class-or-interface-type-conc1
                • Cst-class-declaration-conc3-rep-elem
                • Cst-class-declaration-conc3-rep
                • Cst-class-declaration-conc2-rep-elem
                • Cst-class-declaration-conc2-rep
                • Cst-class-declaration-conc1-rep-elem
                • Cst-class-declaration-conc1-rep
                • Cst-class-body-declaration-conc4
                • Cst-class-body-declaration-conc3
                • Cst-class-body-declaration-conc2
                • Cst-class-body-declaration-conc1
                • Cst-block-statement-conc3-rep-elem
                • Cst-block-statement-conc2-rep-elem
                • Cst-block-statement-conc2-rep
                • Cst-block-statement-conc1-rep-elem
                • Cst-block-statement-conc1-rep
                • Cst-binary-exponent-indicator-conc-rep
                • Cst-assignment-expression-conc2
                • Cst-assignment-expression-conc1
                • Cst-annotation-interface-body-conc
                • Cst-variable-declarator-list-conc
                • Cst-variable-arity-parameter-conc
                • Cst-variable-access-conc2-rep
                • Cst-variable-access-conc2
                • Cst-variable-access-conc1-rep
                • Cst-variable-access-conc1
                • Cst-unann-type-variable-conc-rep-elem
                • Cst-unann-type-variable-conc-rep
                • Cst-unann-type-conc2-rep-elem
                • Cst-unann-type-conc1-rep-elem
                • Cst-unann-interface-type-conc-rep
                • Cst-type-parameter-modifier-conc
                • Cst-type-identifier-conc-rep-elem
                • Cst-type-argument-conc2-rep
                • Cst-type-argument-conc1-rep
                • Cst-text-block-white-space-conc
                • Cst-synchronized-statement-conc
                • Cst-string-character-conc2
                • Cst-string-character-conc1
                • Cst-statement-conc6-rep-elem
                • Cst-statement-conc5-rep-elem
                • Cst-statement-conc4-rep-elem
                • Cst-statement-conc3-rep-elem
                • Cst-statement-conc2-rep-elem
                • Cst-statement-conc1-rep-elem
                • Cst-single-element-annotation-conc
                • Cst-single-character-conc-rep-elem
                • Cst-simple-type-name-conc-rep-elem
                • Cst-resource-specification-conc
                • Cst-resource-conc1-rep-elem
                • Cst-reference-type-conc3-rep
                • Cst-reference-type-conc3
                • Cst-reference-type-conc2-rep
                • Cst-reference-type-conc1-rep
                • Cst-reference-type-conc1
                • Cst-record-component-modifier-conc
                • Cst-record-component-list-conc
                • Cst-raw-input-character-conc-rep-elem
                • Cst-raw-input-character-conc-rep
                • Cst-pre-increment-expression-conc
                • Cst-pre-decrement-expression-conc
                • Cst-postfix-expression-conc4
                • Cst-postfix-expression-conc3
                • Cst-postfix-expression-conc2
                • Cst-postfix-expression-conc1
                • Cst-post-increment-expression-conc
                • Cst-post-decrement-expression-conc
                • Cst-package-modifier-conc-rep-elem
                • Cst-octal-integer-literal-conc
                • Cst-numeric-type-conc2-rep-elem
                • Cst-numeric-type-conc2-rep
                • Cst-numeric-type-conc1-rep-elem
                • Cst-numeric-type-conc1-rep
                • Cst-not-star-not-slash-conc2
                • Cst-not-star-not-slash-conc1
                • Cst-modular-compilation-unit-conc
                • Cst-match-all-pattern-conc-rep-elem
                • Cst-match-all-pattern-conc-rep
                • Cst-left-hand-side-conc3-rep
                • Cst-left-hand-side-conc2-rep
                • Cst-left-hand-side-conc1-rep
                • Cst-left-hand-side-conc1
                • Cst-lambda-body-conc2-rep-elem
                • Cst-lambda-body-conc2-rep
                • Cst-lambda-body-conc1-rep-elem
                • Cst-lambda-body-conc1-rep
                • Cst-java-letter-or-digit-conc-rep
                • Cst-integer-type-suffix-conc-rep-elem
                • Cst-integer-type-suffix-conc-rep
                • Cst-integer-literal-conc4
                • Cst-integer-literal-conc3
                • Cst-integer-literal-conc2-rep
                • Cst-integer-literal-conc2
                • Cst-integer-literal-conc1-rep
                • Cst-integer-literal-conc1
                • Cst-instance-initializer-conc-rep
                • Cst-input-element-conc3-rep
                • Cst-input-element-conc2-rep
                • Cst-input-element-conc1-rep
                • Cst-input-character-conc-rep-elem
                • Cst-import-declaration-conc5
                • Cst-import-declaration-conc3
                • Cst-import-declaration-conc2
                • Cst-import-declaration-conc1
                • Cst-if-then-else-statement-conc
                • Cst-formal-parameter-list-conc
                • Cst-for-statement-conc2-rep
                • Cst-for-statement-conc1-rep
                • Cst-for-init-conc2-rep-elem
                • Cst-for-init-conc1-rep-elem
                • Cst-expression-statement-conc
                • Cst-expression-conc2-rep-elem
                • Cst-expression-conc1-rep-elem
                • Cst-exponent-indicator-conc-rep-elem
                • Cst-exponent-indicator-conc-rep
                • Cst-exception-type-conc2-rep
                • Cst-exception-type-conc1-rep
                • Cst-exception-type-conc1
                • Cst-enum-constant-modifier-conc
                • Cst-enum-body-declarations-conc
                • Cst-enhanced-for-statement-conc
                • Cst-empty-statement-conc-rep-elem
                • Cst-element-value-pair-list-conc
                • Cst-element-value-conc3-rep
                • Cst-element-value-conc2-rep
                • Cst-element-value-conc2
                • Cst-element-value-conc1-rep
                • Cst-digits-and-underscores-conc
                • Cst-decimal-integer-literal-conc
                • Cst-constructor-declarator-conc
                • Cst-constructor-declaration-conc
                • Cst-constant-declaration-conc
                • Cst-component-pattern-list-conc
                • Cst-component-pattern-conc2
                • Cst-component-pattern-conc1
                • Cst-compilation-unit-conc3
                • Cst-compilation-unit-conc2
                • Cst-compilation-unit-conc1
                • Cst-class-declaration-conc3
                • Cst-class-declaration-conc2
                • Cst-class-declaration-conc1
                • Cst-catch-formal-parameter-conc
                • Cst-block-statement-conc3-rep
                • Cst-block-statement-conc3
                • Cst-block-statement-conc2
                • Cst-block-statement-conc1
                • Cst-binary-integer-literal-conc
                • Cst-binary-exponent-indicator-conc
                • Cst-annotation-conc3-rep-elem
                • Cst-annotation-conc3-rep
                • Cst-annotation-conc2-rep-elem
                • Cst-annotation-conc1-rep-elem
                • Cst-yield-statement-conc
                • Cst-while-statement-conc
                • Cst-variable-declarator-conc
                • Cst-unann-type-variable-conc
                • Cst-unann-type-conc2-rep
                • Cst-unann-type-conc2
                • Cst-unann-type-conc1-rep
                • Cst-unann-type-conc1
                • Cst-unann-interface-type-conc
                • Cst-type-pattern-conc-rep-elem
                • Cst-type-pattern-conc-rep
                • Cst-type-parameters-conc
                • Cst-type-parameter-list-conc
                • Cst-type-identifier-conc-rep
                • Cst-type-argument-list-conc
                • Cst-type-argument-conc2
                • Cst-type-argument-conc1
                • Cst-traditional-comment-conc
                • Cst-token-conc5-rep-elem
                • Cst-token-conc4-rep-elem
                • Cst-token-conc3-rep-elem
                • Cst-token-conc2-rep-elem
                • Cst-token-conc1-rep-elem
                • Cst-throw-statement-conc
                • Cst-switch-statement-conc
                • Cst-switch-expression-conc
                • Cst-static-initializer-conc
                • Cst-statement-conc6-rep
                • Cst-statement-conc5-rep
                • Cst-statement-conc5
                • Cst-statement-conc4-rep
                • Cst-statement-conc4
                • Cst-statement-conc3-rep
                • Cst-statement-conc2-rep
                • Cst-statement-conc1-rep
                • Cst-statement-conc1
                • Cst-single-character-conc-rep
                • Cst-single-character-conc
                • Cst-simple-type-name-conc-rep
                • Cst-simple-type-name-conc
                • Cst-return-statement-conc
                • Cst-resource-conc2-rep-elem
                • Cst-resource-conc2-rep
                • Cst-resource-conc1-rep
                • Cst-resource-conc1
                • Cst-reference-type-conc2
                • Cst-record-pattern-conc
                • Cst-record-declaration-conc
                • Cst-receiver-parameter-conc
                • Cst-raw-input-character-conc
                • Cst-primary-conc2-rep-elem
                • Cst-primary-conc2-rep
                • Cst-primary-conc1-rep-elem
                • Cst-primary-conc1-rep
                • Cst-pattern-conc2-rep-elem
                • Cst-pattern-conc2-rep
                • Cst-pattern-conc1-rep-elem
                • Cst-pattern-conc1-rep
                • Cst-package-modifier-conc-rep
                • Cst-package-modifier-conc
                • Cst-package-declaration-conc
                • Cst-numeric-type-conc2
                • Cst-numeric-type-conc1
                • Cst-null-literal-conc-rep-elem
                • Cst-not-star-conc2-rep-elem
                • Cst-not-star-conc2-rep
                • Cst-not-star-conc1-rep-elem
                • Cst-not-star-conc1-rep
                • Cst-normal-annotation-conc
                • Cst-module-declaration-conc
                • Cst-method-name-conc-rep-elem
                • Cst-method-declarator-conc
                • Cst-method-declaration-conc
                • Cst-match-all-pattern-conc
                • Cst-marker-annotation-conc
                • Cst-literal-conc7-rep-elem
                • Cst-literal-conc7-rep
                • Cst-literal-conc6-rep-elem
                • Cst-literal-conc6-rep
                • Cst-literal-conc5-rep-elem
                • Cst-literal-conc5-rep
                • Cst-literal-conc4-rep-elem
                • Cst-literal-conc4-rep
                • Cst-literal-conc3-rep-elem
                • Cst-literal-conc3-rep
                • Cst-literal-conc2-rep-elem
                • Cst-literal-conc2-rep
                • Cst-literal-conc1-rep-elem
                • Cst-literal-conc1-rep
                • Cst-left-hand-side-conc3
                • Cst-left-hand-side-conc2
                • Cst-lambda-expression-conc
                • Cst-lambda-body-conc2
                • Cst-lambda-body-conc1
                • Cst-labeled-statement-conc
                • Cst-keyword-conc2-rep-elem
                • Cst-keyword-conc2-rep
                • Cst-keyword-conc1-rep-elem
                • Cst-keyword-conc1-rep
                • Cst-java-letter-or-digit-conc
                • Cst-java-letter-conc-rep-elem
                • Cst-interface-type-list-conc
                • Cst-interface-type-conc-rep-elem
                • Cst-interface-type-conc-rep
                • Cst-interface-permits-conc
                • Cst-interface-extends-conc
                • Cst-integer-type-suffix-conc
                • Cst-instance-initializer-conc
                • Cst-input-element-conc3
                • Cst-input-element-conc2
                • Cst-input-element-conc1
                • Cst-input-character-conc-rep
                • Cst-input-character-conc
                • Cst-if-then-statement-conc
                • Cst-identifier-conc-rep-elem
                • Cst-identifier-chars-conc
                • Cst-hex-integer-literal-conc
                • Cst-for-update-conc-rep-elem
                • Cst-for-statement-conc2
                • Cst-for-statement-conc1
                • Cst-for-init-conc2-rep
                • Cst-for-init-conc2
                • Cst-for-init-conc1-rep
                • Cst-for-init-conc1
                • Cst-field-declaration-conc
                • Cst-expression-conc2-rep
                • Cst-expression-conc2
                • Cst-expression-conc1-rep
                • Cst-expression-conc1
                • Cst-exponent-indicator-conc
                • Cst-exception-type-list-conc
                • Cst-exception-type-conc2
                • Cst-enum-declaration-conc
                • Cst-enum-constant-list-conc
                • Cst-end-of-line-comment-conc
                • Cst-empty-statement-conc-rep
                • Cst-element-value-pair-conc
                • Cst-element-value-list-conc
                • Cst-element-value-conc3
                • Cst-element-value-conc1
                • Cst-continue-statement-conc
                • Cst-comment-conc2-rep-elem
                • Cst-comment-conc2-rep
                • Cst-comment-conc1-rep-elem
                • Cst-comment-conc1-rep
                • Cst-class-implements-conc
                • Cst-case-pattern-conc-rep-elem
                • Cst-case-constant-conc-rep-elem
                • Cst-case-constant-conc-rep
                • Cst-break-statement-conc
                • Cst-block-statements-conc
                • Cst-binary-exponent-conc
                • Cst-basic-for-statement-conc
                • Cst-array-initializer-conc
                • Cst-annotation-conc3
                • Cst-annotation-conc2-rep
                • Cst-annotation-conc2
                • Cst-annotation-conc1-rep
                • Cst-annotation-conc1
                • Cst-additional-bound-conc
                • Cst-unicode-marker-conc
                • Cst-unicode-escape-conc
                • Cst-underscores-conc
                • Cst-type-variable-conc
                • Cst-type-pattern-conc
                • Cst-type-parameter-conc
                • Cst-type-identifier-conc
                • Cst-type-conc2-rep-elem
                • Cst-type-conc2-rep
                • Cst-type-conc1-rep-elem
                • Cst-type-conc1-rep
                • Cst-type-arguments-conc
                • Cst-token-conc5-rep
                • Cst-token-conc5
                • Cst-token-conc4-rep
                • Cst-token-conc4
                • Cst-token-conc3-rep
                • Cst-token-conc3
                • Cst-token-conc2-rep
                • Cst-token-conc2
                • Cst-token-conc1-rep
                • Cst-token-conc1
                • Cst-text-block-conc
                • Cst-string-literal-conc
                • Cst-statement-conc6
                • Cst-statement-conc3
                • Cst-statement-conc2
                • Cst-signed-integer-conc
                • Cst-resource-list-conc
                • Cst-resource-conc2
                • Cst-record-header-conc
                • Cst-record-body-conc
                • Cst-primary-conc2
                • Cst-primary-conc1
                • Cst-pattern-conc2
                • Cst-pattern-conc1
                • Cst-null-literal-conc-rep
                • Cst-null-literal-conc
                • Cst-not-star-conc2
                • Cst-not-star-conc1
                • Cst-method-name-conc-rep
                • Cst-method-name-conc
                • Cst-literal-conc7
                • Cst-literal-conc6
                • Cst-literal-conc5
                • Cst-literal-conc4
                • Cst-literal-conc3
                • Cst-literal-conc2
                • Cst-literal-conc1
                • Cst-keyword-conc2
                • Cst-keyword-conc1
                • Cst-java-letter-conc-rep
                • Cst-java-letter-conc
                • Cst-interface-type-conc
                • Cst-interface-body-conc
                • Cst-identifier-conc-rep
                • Cst-hex-numeral-conc
                • Cst-for-update-conc-rep
                • Cst-for-update-conc
                • Cst-exponent-part-conc
                • Cst-enum-constant-conc
                • Cst-empty-statement-conc
                • Cst-do-statement-conc
                • Cst-default-value-conc
                • Cst-comment-conc2
                • Cst-comment-conc1
                • Cst-class-permits-conc
                • Cst-class-extends-conc
                • Cst-class-body-conc
                • Cst-catch-type-conc
                • Cst-catch-clause-conc
                • Cst-case-pattern-conc-rep
                • Cst-case-pattern-conc
                • Cst-case-constant-conc
                • Cst-binary-numeral-conc
                • Cst-assignment-conc
                • Cst-argument-list-conc
                • Cst-wildcard-conc
                • Cst-type-conc2
                • Cst-type-conc1
                • Cst-throws-conc
                • Cst-sub-conc-rep-elem
                • Cst-sub-conc-rep
                • Cst-input-conc
                • Cst-identifier-conc
                • Cst-finally-conc
                • Cst-enum-body-conc
                • Cst-dim-exprs-conc
                • Cst-dim-expr-conc
                • Cst-catches-conc
                • Cst-block-conc
                • Cst-sub-conc
                • Cst-guard-conc
                • Cst-dims-conc
                • Cst-%x0-ffff-nat
                • *syntactic-grammar*
                • *lexical-grammar*
              • Unicode-escapes
              • Unicode-input-char
              • Escape-sequence
              • Identifiers
              • Primitive-types
              • Reference-types
              • Unicode-characters
              • Keywords
              • Integer-literals
              • String-literals
              • Octal-digits
              • Hexadecimal-digits
              • Decimal-digits
              • Binary-digits
              • Character-literals
              • Null-literal
              • Floating-point-literals
              • Boolean-literals
              • Package-names
              • Literals
            • Semantics
        • 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
  • Grammar

Abnf-tree-list-with-root-p

Lift abnf-tree-with-root-p to lists.

Signature
(abnf-tree-list-with-root-p x rulename) → std::bool

This is an ordinary std::deflist. It is "strict" in that it requires x to be a "properly" nil-terminated list.

Definitions and Theorems

Function: abnf-tree-list-with-root-p

(defun abnf-tree-list-with-root-p (x rulename)
  (declare (xargs :guard (stringp rulename)))
  (if (consp x)
      (and (abnf-tree-with-root-p (car x) rulename)
           (abnf-tree-list-with-root-p (cdr x)
                                       rulename))
    (null x)))

Theorem: abnf-tree-list-with-root-p-of-str-fix-rulename

(defthm abnf-tree-list-with-root-p-of-str-fix-rulename
  (equal (abnf-tree-list-with-root-p x (str-fix rulename))
         (abnf-tree-list-with-root-p x rulename)))

Theorem: abnf-tree-list-with-root-p-streqv-congruence-on-rulename

(defthm abnf-tree-list-with-root-p-streqv-congruence-on-rulename
  (implies (acl2::streqv rulename rulename-equiv)
           (equal (abnf-tree-list-with-root-p x rulename)
                  (abnf-tree-list-with-root-p x rulename-equiv)))
  :rule-classes :congruence)

Theorem: abnf-tree-listp-when-abnf-tree-list-with-root-p

(defthm abnf-tree-listp-when-abnf-tree-list-with-root-p
  (implies (abnf-tree-list-with-root-p trees rulename)
           (abnf::tree-listp trees)))

Theorem: unicode-listp-of-string-of-abnf-tree-list-with-root

(defthm unicode-listp-of-string-of-abnf-tree-list-with-root
  (implies (abnf-tree-list-with-root-p trees rulename)
           (unicode-listp (abnf::tree-list->string trees))))

Subtopics

Abnf-tree-list-with-root-p-basics
Basic theorems about abnf-tree-list-with-root-p, generated by std::deflist.