Tree operations specialized to *grammar*.
Function:
(defun cst-matchp$ (abnf::tree abnf::elem) (declare (xargs :guard (and (abnf::treep abnf::tree) (abnf::elementp abnf::elem)))) (let ((__function__ 'cst-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-terminatedp abnf::tree) (abnf::tree-match-element-p abnf::tree abnf::elem *grammar*))))
Theorem:
(defthm booleanp-of-cst-matchp$ (b* ((abnf::yes/no (cst-matchp$ abnf::tree abnf::elem))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-matchp$-of-tree-fix-tree (equal (cst-matchp$ (abnf::tree-fix abnf::tree) abnf::elem) (cst-matchp$ abnf::tree abnf::elem)))
Theorem:
(defthm cst-matchp$-tree-equiv-congruence-on-tree (implies (abnf::tree-equiv abnf::tree tree-equiv) (equal (cst-matchp$ abnf::tree abnf::elem) (cst-matchp$ tree-equiv abnf::elem))) :rule-classes :congruence)
Theorem:
(defthm cst-matchp$-of-element-fix-elem (equal (cst-matchp$ abnf::tree (abnf::element-fix abnf::elem)) (cst-matchp$ abnf::tree abnf::elem)))
Theorem:
(defthm cst-matchp$-element-equiv-congruence-on-elem (implies (abnf::element-equiv abnf::elem elem-equiv) (equal (cst-matchp$ abnf::tree abnf::elem) (cst-matchp$ abnf::tree elem-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-elem-matchp$ (abnf::trees abnf::elem) (declare (xargs :guard (and (abnf::tree-listp abnf::trees) (abnf::elementp abnf::elem)))) (let ((__function__ 'cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-terminatedp abnf::trees) (abnf::tree-list-match-element-p abnf::trees abnf::elem *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-elem-matchp$ (b* ((abnf::yes/no (cst-list-elem-matchp$ abnf::trees abnf::elem))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-elem-matchp$-of-tree-list-fix-trees (equal (cst-list-elem-matchp$ (abnf::tree-list-fix abnf::trees) abnf::elem) (cst-list-elem-matchp$ abnf::trees abnf::elem)))
Theorem:
(defthm cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (abnf::tree-list-equiv abnf::trees trees-equiv) (equal (cst-list-elem-matchp$ abnf::trees abnf::elem) (cst-list-elem-matchp$ trees-equiv abnf::elem))) :rule-classes :congruence)
Theorem:
(defthm cst-list-elem-matchp$-of-element-fix-elem (equal (cst-list-elem-matchp$ abnf::trees (abnf::element-fix abnf::elem)) (cst-list-elem-matchp$ abnf::trees abnf::elem)))
Theorem:
(defthm cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (abnf::element-equiv abnf::elem elem-equiv) (equal (cst-list-elem-matchp$ abnf::trees abnf::elem) (cst-list-elem-matchp$ abnf::trees elem-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-rep-matchp$ (abnf::trees abnf::rep) (declare (xargs :guard (and (abnf::tree-listp abnf::trees) (abnf::repetitionp abnf::rep)))) (let ((__function__ 'cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-terminatedp abnf::trees) (abnf::tree-list-match-repetition-p abnf::trees abnf::rep *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-rep-matchp$ (b* ((abnf::yes/no (cst-list-rep-matchp$ abnf::trees abnf::rep))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-rep-matchp$-of-tree-list-fix-trees (equal (cst-list-rep-matchp$ (abnf::tree-list-fix abnf::trees) abnf::rep) (cst-list-rep-matchp$ abnf::trees abnf::rep)))
Theorem:
(defthm cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (abnf::tree-list-equiv abnf::trees trees-equiv) (equal (cst-list-rep-matchp$ abnf::trees abnf::rep) (cst-list-rep-matchp$ trees-equiv abnf::rep))) :rule-classes :congruence)
Theorem:
(defthm cst-list-rep-matchp$-of-repetition-fix-rep (equal (cst-list-rep-matchp$ abnf::trees (abnf::repetition-fix abnf::rep)) (cst-list-rep-matchp$ abnf::trees abnf::rep)))
Theorem:
(defthm cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (abnf::repetition-equiv abnf::rep rep-equiv) (equal (cst-list-rep-matchp$ abnf::trees abnf::rep) (cst-list-rep-matchp$ abnf::trees rep-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-list-conc-matchp$ (abnf::treess abnf::conc) (declare (xargs :guard (and (abnf::tree-list-listp abnf::treess) (abnf::concatenationp abnf::conc)))) (let ((__function__ 'cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-list-terminatedp abnf::treess) (abnf::tree-list-list-match-concatenation-p abnf::treess abnf::conc *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-list-conc-matchp$ (b* ((abnf::yes/no (cst-list-list-conc-matchp$ abnf::treess abnf::conc))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (cst-list-list-conc-matchp$ (abnf::tree-list-list-fix abnf::treess) abnf::conc) (cst-list-list-conc-matchp$ abnf::treess abnf::conc)))
Theorem:
(defthm cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (abnf::tree-list-list-equiv abnf::treess treess-equiv) (equal (cst-list-list-conc-matchp$ abnf::treess abnf::conc) (cst-list-list-conc-matchp$ treess-equiv abnf::conc))) :rule-classes :congruence)
Theorem:
(defthm cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (cst-list-list-conc-matchp$ abnf::treess (abnf::concatenation-fix abnf::conc)) (cst-list-list-conc-matchp$ abnf::treess abnf::conc)))
Theorem:
(defthm cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (abnf::concatenation-equiv abnf::conc conc-equiv) (equal (cst-list-list-conc-matchp$ abnf::treess abnf::conc) (cst-list-list-conc-matchp$ abnf::treess conc-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-list-alt-matchp$ (abnf::treess abnf::alt) (declare (xargs :guard (and (abnf::tree-list-listp abnf::treess) (abnf::alternationp abnf::alt)))) (let ((__function__ 'cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-list-terminatedp abnf::treess) (abnf::tree-list-list-match-alternation-p abnf::treess abnf::alt *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-list-alt-matchp$ (b* ((abnf::yes/no (cst-list-list-alt-matchp$ abnf::treess abnf::alt))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (cst-list-list-alt-matchp$ (abnf::tree-list-list-fix abnf::treess) abnf::alt) (cst-list-list-alt-matchp$ abnf::treess abnf::alt)))
Theorem:
(defthm cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (abnf::tree-list-list-equiv abnf::treess treess-equiv) (equal (cst-list-list-alt-matchp$ abnf::treess abnf::alt) (cst-list-list-alt-matchp$ treess-equiv abnf::alt))) :rule-classes :congruence)
Theorem:
(defthm cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (cst-list-list-alt-matchp$ abnf::treess (abnf::alternation-fix abnf::alt)) (cst-list-list-alt-matchp$ abnf::treess abnf::alt)))
Theorem:
(defthm cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (abnf::alternation-equiv abnf::alt alt-equiv) (equal (cst-list-list-alt-matchp$ abnf::treess abnf::alt) (cst-list-list-alt-matchp$ abnf::treess alt-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-unicode-input-character-nonleaf (implies (cst-matchp abnf::cst "unicode-input-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unicode-escape-nonleaf (implies (cst-matchp abnf::cst "unicode-escape") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unicode-marker-nonleaf (implies (cst-matchp abnf::cst "unicode-marker") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-digit-nonleaf (implies (cst-matchp abnf::cst "hex-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-raw-input-character-nonleaf (implies (cst-matchp abnf::cst "raw-input-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-line-terminator-nonleaf (implies (cst-matchp abnf::cst "line-terminator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-input-character-nonleaf (implies (cst-matchp abnf::cst "input-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-input-nonleaf (implies (cst-matchp abnf::cst "input") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-input-element-nonleaf (implies (cst-matchp abnf::cst "input-element") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-token-nonleaf (implies (cst-matchp abnf::cst "token") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-sub-nonleaf (implies (cst-matchp abnf::cst "sub") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-white-space-nonleaf (implies (cst-matchp abnf::cst "white-space") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-comment-nonleaf (implies (cst-matchp abnf::cst "comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-traditional-comment-nonleaf (implies (cst-matchp abnf::cst "traditional-comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-comment-tail-nonleaf (implies (cst-matchp abnf::cst "comment-tail") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-comment-tail-star-nonleaf (implies (cst-matchp abnf::cst "comment-tail-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-not-star-nonleaf (implies (cst-matchp abnf::cst "not-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-not-star-not-slash-nonleaf (implies (cst-matchp abnf::cst "not-star-not-slash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-end-of-line-comment-nonleaf (implies (cst-matchp abnf::cst "end-of-line-comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-identifier-nonleaf (implies (cst-matchp abnf::cst "identifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-identifier-chars-nonleaf (implies (cst-matchp abnf::cst "identifier-chars") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-java-letter-nonleaf (implies (cst-matchp abnf::cst "java-letter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-java-letter-or-digit-nonleaf (implies (cst-matchp abnf::cst "java-letter-or-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-identifier-nonleaf (implies (cst-matchp abnf::cst "type-identifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unqualified-method-identifier-nonleaf (implies (cst-matchp abnf::cst "unqualified-method-identifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-keyword-nonleaf (implies (cst-matchp abnf::cst "keyword") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-literal-nonleaf (implies (cst-matchp abnf::cst "literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-integer-literal-nonleaf (implies (cst-matchp abnf::cst "integer-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-decimal-integer-literal-nonleaf (implies (cst-matchp abnf::cst "decimal-integer-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-integer-literal-nonleaf (implies (cst-matchp abnf::cst "hex-integer-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-integer-literal-nonleaf (implies (cst-matchp abnf::cst "octal-integer-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-integer-literal-nonleaf (implies (cst-matchp abnf::cst "binary-integer-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-integer-type-suffix-nonleaf (implies (cst-matchp abnf::cst "integer-type-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-decimal-numeral-nonleaf (implies (cst-matchp abnf::cst "decimal-numeral") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-non-zero-digit-nonleaf (implies (cst-matchp abnf::cst "non-zero-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-digits-nonleaf (implies (cst-matchp abnf::cst "digits") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-digit-nonleaf (implies (cst-matchp abnf::cst "digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-digits-and-underscores-nonleaf (implies (cst-matchp abnf::cst "digits-and-underscores") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-digit-or-underscore-nonleaf (implies (cst-matchp abnf::cst "digit-or-underscore") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-underscores-nonleaf (implies (cst-matchp abnf::cst "underscores") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-numeral-nonleaf (implies (cst-matchp abnf::cst "hex-numeral") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-digits-nonleaf (implies (cst-matchp abnf::cst "hex-digits") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-digits-and-underscores-nonleaf (implies (cst-matchp abnf::cst "hex-digits-and-underscores") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-digit-or-underscore-nonleaf (implies (cst-matchp abnf::cst "hex-digit-or-underscore") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-numeral-nonleaf (implies (cst-matchp abnf::cst "octal-numeral") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-digits-nonleaf (implies (cst-matchp abnf::cst "octal-digits") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-digit-nonleaf (implies (cst-matchp abnf::cst "octal-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-digits-and-underscores-nonleaf (implies (cst-matchp abnf::cst "octal-digits-and-underscores") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-digit-or-underscore-nonleaf (implies (cst-matchp abnf::cst "octal-digit-or-underscore") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-numeral-nonleaf (implies (cst-matchp abnf::cst "binary-numeral") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-digits-nonleaf (implies (cst-matchp abnf::cst "binary-digits") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-digit-nonleaf (implies (cst-matchp abnf::cst "binary-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-digits-and-underscores-nonleaf (implies (cst-matchp abnf::cst "binary-digits-and-underscores") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-digit-or-underscore-nonleaf (implies (cst-matchp abnf::cst "binary-digit-or-underscore") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-floating-point-literal-nonleaf (implies (cst-matchp abnf::cst "floating-point-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-decimal-floating-point-literal-nonleaf (implies (cst-matchp abnf::cst "decimal-floating-point-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exponent-part-nonleaf (implies (cst-matchp abnf::cst "exponent-part") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exponent-indicator-nonleaf (implies (cst-matchp abnf::cst "exponent-indicator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-signed-integer-nonleaf (implies (cst-matchp abnf::cst "signed-integer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-sign-nonleaf (implies (cst-matchp abnf::cst "sign") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-float-type-suffix-nonleaf (implies (cst-matchp abnf::cst "float-type-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-floating-point-literal-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-floating-point-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-significand-nonleaf (implies (cst-matchp abnf::cst "hex-significand") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-exponent-nonleaf (implies (cst-matchp abnf::cst "binary-exponent") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-exponent-indicator-nonleaf (implies (cst-matchp abnf::cst "binary-exponent-indicator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-boolean-literal-nonleaf (implies (cst-matchp abnf::cst "boolean-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-literal-nonleaf (implies (cst-matchp abnf::cst "character-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-single-character-nonleaf (implies (cst-matchp abnf::cst "single-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-string-literal-nonleaf (implies (cst-matchp abnf::cst "string-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-string-character-nonleaf (implies (cst-matchp abnf::cst "string-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-escape-sequence-nonleaf (implies (cst-matchp abnf::cst "escape-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-escape-nonleaf (implies (cst-matchp abnf::cst "octal-escape") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-zero-to-three-nonleaf (implies (cst-matchp abnf::cst "zero-to-three") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-null-literal-nonleaf (implies (cst-matchp abnf::cst "null-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-separator-nonleaf (implies (cst-matchp abnf::cst "separator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-operator-nonleaf (implies (cst-matchp abnf::cst "operator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-nonleaf (implies (cst-matchp abnf::cst "type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-primitive-type-nonleaf (implies (cst-matchp abnf::cst "primitive-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-numeric-type-nonleaf (implies (cst-matchp abnf::cst "numeric-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-integral-type-nonleaf (implies (cst-matchp abnf::cst "integral-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-floating-point-type-nonleaf (implies (cst-matchp abnf::cst "floating-point-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-reference-type-nonleaf (implies (cst-matchp abnf::cst "reference-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-or-interface-type-nonleaf (implies (cst-matchp abnf::cst "class-or-interface-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-type-nonleaf (implies (cst-matchp abnf::cst "class-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-type-nonleaf (implies (cst-matchp abnf::cst "interface-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-variable-nonleaf (implies (cst-matchp abnf::cst "type-variable") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-array-type-nonleaf (implies (cst-matchp abnf::cst "array-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-dims-nonleaf (implies (cst-matchp abnf::cst "dims") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-parameter-nonleaf (implies (cst-matchp abnf::cst "type-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-parameter-modifier-nonleaf (implies (cst-matchp abnf::cst "type-parameter-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-bound-nonleaf (implies (cst-matchp abnf::cst "type-bound") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-additional-bound-nonleaf (implies (cst-matchp abnf::cst "additional-bound") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-arguments-nonleaf (implies (cst-matchp abnf::cst "type-arguments") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-argument-list-nonleaf (implies (cst-matchp abnf::cst "type-argument-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-argument-nonleaf (implies (cst-matchp abnf::cst "type-argument") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-wildcard-nonleaf (implies (cst-matchp abnf::cst "wildcard") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-wildcard-bounds-nonleaf (implies (cst-matchp abnf::cst "wildcard-bounds") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-module-name-nonleaf (implies (cst-matchp abnf::cst "module-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-package-name-nonleaf (implies (cst-matchp abnf::cst "package-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-name-nonleaf (implies (cst-matchp abnf::cst "type-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-package-or-type-name-nonleaf (implies (cst-matchp abnf::cst "package-or-type-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-expression-name-nonleaf (implies (cst-matchp abnf::cst "expression-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-name-nonleaf (implies (cst-matchp abnf::cst "method-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-ambiguous-name-nonleaf (implies (cst-matchp abnf::cst "ambiguous-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-compilation-unit-nonleaf (implies (cst-matchp abnf::cst "compilation-unit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-ordinary-compilation-unit-nonleaf (implies (cst-matchp abnf::cst "ordinary-compilation-unit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-modular-compilation-unit-nonleaf (implies (cst-matchp abnf::cst "modular-compilation-unit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-package-declaration-nonleaf (implies (cst-matchp abnf::cst "package-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-package-modifier-nonleaf (implies (cst-matchp abnf::cst "package-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-import-declaration-nonleaf (implies (cst-matchp abnf::cst "import-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-single-type-import-declaration-nonleaf (implies (cst-matchp abnf::cst "single-type-import-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-import-on-demand-declaration-nonleaf (implies (cst-matchp abnf::cst "type-import-on-demand-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-single-static-import-declaration-nonleaf (implies (cst-matchp abnf::cst "single-static-import-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-static-import-on-demand-declaration-nonleaf (implies (cst-matchp abnf::cst "static-import-on-demand-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-declaration-nonleaf (implies (cst-matchp abnf::cst "type-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-module-declaration-nonleaf (implies (cst-matchp abnf::cst "module-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-module-directive-nonleaf (implies (cst-matchp abnf::cst "module-directive") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-requires-modifier-nonleaf (implies (cst-matchp abnf::cst "requires-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-declaration-nonleaf (implies (cst-matchp abnf::cst "class-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-normal-class-declaration-nonleaf (implies (cst-matchp abnf::cst "normal-class-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-modifier-nonleaf (implies (cst-matchp abnf::cst "class-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-parameters-nonleaf (implies (cst-matchp abnf::cst "type-parameters") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-parameter-list-nonleaf (implies (cst-matchp abnf::cst "type-parameter-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-superclass-nonleaf (implies (cst-matchp abnf::cst "superclass") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-superinterfaces-nonleaf (implies (cst-matchp abnf::cst "superinterfaces") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-type-list-nonleaf (implies (cst-matchp abnf::cst "interface-type-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-body-nonleaf (implies (cst-matchp abnf::cst "class-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-body-declaration-nonleaf (implies (cst-matchp abnf::cst "class-body-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-member-declaration-nonleaf (implies (cst-matchp abnf::cst "class-member-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-field-declaration-nonleaf (implies (cst-matchp abnf::cst "field-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-declarator-list-nonleaf (implies (cst-matchp abnf::cst "variable-declarator-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-declarator-nonleaf (implies (cst-matchp abnf::cst "variable-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-declarator-id-nonleaf (implies (cst-matchp abnf::cst "variable-declarator-id") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-initializer-nonleaf (implies (cst-matchp abnf::cst "variable-initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-type-nonleaf (implies (cst-matchp abnf::cst "unann-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-primitive-type-nonleaf (implies (cst-matchp abnf::cst "unann-primitive-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-reference-type-nonleaf (implies (cst-matchp abnf::cst "unann-reference-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-class-or-interface-type-nonleaf (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-class-type-nonleaf (implies (cst-matchp abnf::cst "unann-class-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-interface-type-nonleaf (implies (cst-matchp abnf::cst "unann-interface-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-type-variable-nonleaf (implies (cst-matchp abnf::cst "unann-type-variable") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unann-array-type-nonleaf (implies (cst-matchp abnf::cst "unann-array-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-field-modifier-nonleaf (implies (cst-matchp abnf::cst "field-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-declaration-nonleaf (implies (cst-matchp abnf::cst "method-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-header-nonleaf (implies (cst-matchp abnf::cst "method-header") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-declarator-nonleaf (implies (cst-matchp abnf::cst "method-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-receiver-parameter-nonleaf (implies (cst-matchp abnf::cst "receiver-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-formal-parameter-list-nonleaf (implies (cst-matchp abnf::cst "formal-parameter-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-formal-parameter-nonleaf (implies (cst-matchp abnf::cst "formal-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-arity-parameter-nonleaf (implies (cst-matchp abnf::cst "variable-arity-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-modifier-nonleaf (implies (cst-matchp abnf::cst "variable-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-modifier-nonleaf (implies (cst-matchp abnf::cst "method-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-result-nonleaf (implies (cst-matchp abnf::cst "result") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-throws-nonleaf (implies (cst-matchp abnf::cst "throws") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exception-type-list-nonleaf (implies (cst-matchp abnf::cst "exception-type-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exception-type-nonleaf (implies (cst-matchp abnf::cst "exception-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-body-nonleaf (implies (cst-matchp abnf::cst "method-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-instance-initializer-nonleaf (implies (cst-matchp abnf::cst "instance-initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-static-initializer-nonleaf (implies (cst-matchp abnf::cst "static-initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constructor-declaration-nonleaf (implies (cst-matchp abnf::cst "constructor-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constructor-declarator-nonleaf (implies (cst-matchp abnf::cst "constructor-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-simple-type-name-nonleaf (implies (cst-matchp abnf::cst "simple-type-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constructor-modifier-nonleaf (implies (cst-matchp abnf::cst "constructor-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constructor-body-nonleaf (implies (cst-matchp abnf::cst "constructor-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-explicit-constructor-invocation-nonleaf (implies (cst-matchp abnf::cst "explicit-constructor-invocation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-declaration-nonleaf (implies (cst-matchp abnf::cst "enum-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-body-nonleaf (implies (cst-matchp abnf::cst "enum-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-constant-list-nonleaf (implies (cst-matchp abnf::cst "enum-constant-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-constant-nonleaf (implies (cst-matchp abnf::cst "enum-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-constant-modifier-nonleaf (implies (cst-matchp abnf::cst "enum-constant-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-body-declarations-nonleaf (implies (cst-matchp abnf::cst "enum-body-declarations") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-declaration-nonleaf (implies (cst-matchp abnf::cst "interface-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-normal-interface-declaration-nonleaf (implies (cst-matchp abnf::cst "normal-interface-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-modifier-nonleaf (implies (cst-matchp abnf::cst "interface-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-extends-interfaces-nonleaf (implies (cst-matchp abnf::cst "extends-interfaces") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-body-nonleaf (implies (cst-matchp abnf::cst "interface-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-member-declaration-nonleaf (implies (cst-matchp abnf::cst "interface-member-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constant-declaration-nonleaf (implies (cst-matchp abnf::cst "constant-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constant-modifier-nonleaf (implies (cst-matchp abnf::cst "constant-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-method-declaration-nonleaf (implies (cst-matchp abnf::cst "interface-method-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-interface-method-modifier-nonleaf (implies (cst-matchp abnf::cst "interface-method-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-type-declaration-nonleaf (implies (cst-matchp abnf::cst "annotation-type-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-type-body-nonleaf (implies (cst-matchp abnf::cst "annotation-type-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-type-member-declaration-nonleaf (implies (cst-matchp abnf::cst "annotation-type-member-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-type-element-declaration-nonleaf (implies (cst-matchp abnf::cst "annotation-type-element-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-type-element-modifier-nonleaf (implies (cst-matchp abnf::cst "annotation-type-element-modifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-default-value-nonleaf (implies (cst-matchp abnf::cst "default-value") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-annotation-nonleaf (implies (cst-matchp abnf::cst "annotation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-normal-annotation-nonleaf (implies (cst-matchp abnf::cst "normal-annotation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-element-value-pair-list-nonleaf (implies (cst-matchp abnf::cst "element-value-pair-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-element-value-pair-nonleaf (implies (cst-matchp abnf::cst "element-value-pair") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-element-value-nonleaf (implies (cst-matchp abnf::cst "element-value") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-element-value-array-initializer-nonleaf (implies (cst-matchp abnf::cst "element-value-array-initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-element-value-list-nonleaf (implies (cst-matchp abnf::cst "element-value-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-marker-annotation-nonleaf (implies (cst-matchp abnf::cst "marker-annotation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-single-element-annotation-nonleaf (implies (cst-matchp abnf::cst "single-element-annotation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-array-initializer-nonleaf (implies (cst-matchp abnf::cst "array-initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-initializer-list-nonleaf (implies (cst-matchp abnf::cst "variable-initializer-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-block-nonleaf (implies (cst-matchp abnf::cst "block") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-block-statements-nonleaf (implies (cst-matchp abnf::cst "block-statements") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-block-statement-nonleaf (implies (cst-matchp abnf::cst "block-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-local-variable-declaration-statement-nonleaf (implies (cst-matchp abnf::cst "local-variable-declaration-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-local-variable-declaration-nonleaf (implies (cst-matchp abnf::cst "local-variable-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-local-variable-type-nonleaf (implies (cst-matchp abnf::cst "local-variable-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-statement-nonleaf (implies (cst-matchp abnf::cst "statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-statement-without-trailing-substatement-nonleaf (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-empty-statement-nonleaf (implies (cst-matchp abnf::cst "empty-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-labeled-statement-nonleaf (implies (cst-matchp abnf::cst "labeled-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-labeled-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "labeled-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-expression-statement-nonleaf (implies (cst-matchp abnf::cst "expression-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-statement-expression-nonleaf (implies (cst-matchp abnf::cst "statement-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-if-then-statement-nonleaf (implies (cst-matchp abnf::cst "if-then-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-if-then-else-statement-nonleaf (implies (cst-matchp abnf::cst "if-then-else-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-if-then-else-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "if-then-else-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-assert-statement-nonleaf (implies (cst-matchp abnf::cst "assert-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-statement-nonleaf (implies (cst-matchp abnf::cst "switch-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-block-nonleaf (implies (cst-matchp abnf::cst "switch-block") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-rule-nonleaf (implies (cst-matchp abnf::cst "switch-rule") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-block-statement-group-nonleaf (implies (cst-matchp abnf::cst "switch-block-statement-group") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-label-nonleaf (implies (cst-matchp abnf::cst "switch-label") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-case-constant-nonleaf (implies (cst-matchp abnf::cst "case-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-while-statement-nonleaf (implies (cst-matchp abnf::cst "while-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-while-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "while-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-do-statement-nonleaf (implies (cst-matchp abnf::cst "do-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-for-statement-nonleaf (implies (cst-matchp abnf::cst "for-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-for-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "for-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-for-statement-nonleaf (implies (cst-matchp abnf::cst "basic-for-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-for-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "basic-for-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-for-init-nonleaf (implies (cst-matchp abnf::cst "for-init") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-for-update-nonleaf (implies (cst-matchp abnf::cst "for-update") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-statement-expression-list-nonleaf (implies (cst-matchp abnf::cst "statement-expression-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enhanced-for-statement-nonleaf (implies (cst-matchp abnf::cst "enhanced-for-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-nonleaf (implies (cst-matchp abnf::cst "enhanced-for-statement-no-short-if") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-break-statement-nonleaf (implies (cst-matchp abnf::cst "break-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-continue-statement-nonleaf (implies (cst-matchp abnf::cst "continue-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-return-statement-nonleaf (implies (cst-matchp abnf::cst "return-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-throw-statement-nonleaf (implies (cst-matchp abnf::cst "throw-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-synchronized-statement-nonleaf (implies (cst-matchp abnf::cst "synchronized-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-try-statement-nonleaf (implies (cst-matchp abnf::cst "try-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-catches-nonleaf (implies (cst-matchp abnf::cst "catches") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-catch-clause-nonleaf (implies (cst-matchp abnf::cst "catch-clause") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-catch-formal-parameter-nonleaf (implies (cst-matchp abnf::cst "catch-formal-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-catch-type-nonleaf (implies (cst-matchp abnf::cst "catch-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-finally-nonleaf (implies (cst-matchp abnf::cst "finally") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-try-with-resources-statement-nonleaf (implies (cst-matchp abnf::cst "try-with-resources-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-resource-specification-nonleaf (implies (cst-matchp abnf::cst "resource-specification") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-resource-list-nonleaf (implies (cst-matchp abnf::cst "resource-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-resource-nonleaf (implies (cst-matchp abnf::cst "resource") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-variable-access-nonleaf (implies (cst-matchp abnf::cst "variable-access") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-yield-statement-nonleaf (implies (cst-matchp abnf::cst "yield-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-expression-nonleaf (implies (cst-matchp abnf::cst "expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-primary-nonleaf (implies (cst-matchp abnf::cst "primary") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-primary-no-new-array-nonleaf (implies (cst-matchp abnf::cst "primary-no-new-array") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-literal-nonleaf (implies (cst-matchp abnf::cst "class-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-instance-creation-expression-nonleaf (implies (cst-matchp abnf::cst "class-instance-creation-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-nonleaf (implies (cst-matchp abnf::cst "unqualified-class-instance-creation-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-nonleaf (implies (cst-matchp abnf::cst "class-or-interface-type-to-instantiate") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-arguments-or-diamond-nonleaf (implies (cst-matchp abnf::cst "type-arguments-or-diamond") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-array-creation-expression-nonleaf (implies (cst-matchp abnf::cst "array-creation-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-dim-exprs-nonleaf (implies (cst-matchp abnf::cst "dim-exprs") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-dim-expr-nonleaf (implies (cst-matchp abnf::cst "dim-expr") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-array-access-nonleaf (implies (cst-matchp abnf::cst "array-access") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-field-access-nonleaf (implies (cst-matchp abnf::cst "field-access") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-invocation-nonleaf (implies (cst-matchp abnf::cst "method-invocation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-argument-list-nonleaf (implies (cst-matchp abnf::cst "argument-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-method-reference-nonleaf (implies (cst-matchp abnf::cst "method-reference") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-postfix-expression-nonleaf (implies (cst-matchp abnf::cst "postfix-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-post-increment-expression-nonleaf (implies (cst-matchp abnf::cst "post-increment-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-post-decrement-expression-nonleaf (implies (cst-matchp abnf::cst "post-decrement-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unary-expression-nonleaf (implies (cst-matchp abnf::cst "unary-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-pre-increment-expression-nonleaf (implies (cst-matchp abnf::cst "pre-increment-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-pre-decrement-expression-nonleaf (implies (cst-matchp abnf::cst "pre-decrement-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unary-expression-not-plus-minus-nonleaf (implies (cst-matchp abnf::cst "unary-expression-not-plus-minus") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-cast-expression-nonleaf (implies (cst-matchp abnf::cst "cast-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-multiplicative-expression-nonleaf (implies (cst-matchp abnf::cst "multiplicative-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-additive-expression-nonleaf (implies (cst-matchp abnf::cst "additive-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-shift-expression-nonleaf (implies (cst-matchp abnf::cst "shift-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-relational-expression-nonleaf (implies (cst-matchp abnf::cst "relational-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-equality-expression-nonleaf (implies (cst-matchp abnf::cst "equality-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-and-expression-nonleaf (implies (cst-matchp abnf::cst "and-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exclusive-or-expression-nonleaf (implies (cst-matchp abnf::cst "exclusive-or-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-inclusive-or-expression-nonleaf (implies (cst-matchp abnf::cst "inclusive-or-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-conditional-and-expression-nonleaf (implies (cst-matchp abnf::cst "conditional-and-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-conditional-or-expression-nonleaf (implies (cst-matchp abnf::cst "conditional-or-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-conditional-expression-nonleaf (implies (cst-matchp abnf::cst "conditional-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-assignment-expression-nonleaf (implies (cst-matchp abnf::cst "assignment-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-assignment-nonleaf (implies (cst-matchp abnf::cst "assignment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-left-hand-side-nonleaf (implies (cst-matchp abnf::cst "left-hand-side") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-assignment-operator-nonleaf (implies (cst-matchp abnf::cst "assignment-operator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-expression-nonleaf (implies (cst-matchp abnf::cst "lambda-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-parameters-nonleaf (implies (cst-matchp abnf::cst "lambda-parameters") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-parameter-list-nonleaf (implies (cst-matchp abnf::cst "lambda-parameter-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-parameter-nonleaf (implies (cst-matchp abnf::cst "lambda-parameter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-parameter-type-nonleaf (implies (cst-matchp abnf::cst "lambda-parameter-type") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lambda-body-nonleaf (implies (cst-matchp abnf::cst "lambda-body") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-switch-expression-nonleaf (implies (cst-matchp abnf::cst "switch-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-constant-expression-nonleaf (implies (cst-matchp abnf::cst "constant-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unicode-input-character-rulename (implies (cst-matchp abnf::cst "unicode-input-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unicode-input-character"))))
Theorem:
(defthm cst-unicode-escape-rulename (implies (cst-matchp abnf::cst "unicode-escape") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unicode-escape"))))
Theorem:
(defthm cst-unicode-marker-rulename (implies (cst-matchp abnf::cst "unicode-marker") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unicode-marker"))))
Theorem:
(defthm cst-hex-digit-rulename (implies (cst-matchp abnf::cst "hex-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-digit"))))
Theorem:
(defthm cst-raw-input-character-rulename (implies (cst-matchp abnf::cst "raw-input-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "raw-input-character"))))
Theorem:
(defthm cst-line-terminator-rulename (implies (cst-matchp abnf::cst "line-terminator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "line-terminator"))))
Theorem:
(defthm cst-input-character-rulename (implies (cst-matchp abnf::cst "input-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "input-character"))))
Theorem:
(defthm cst-input-rulename (implies (cst-matchp abnf::cst "input") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "input"))))
Theorem:
(defthm cst-input-element-rulename (implies (cst-matchp abnf::cst "input-element") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "input-element"))))
Theorem:
(defthm cst-token-rulename (implies (cst-matchp abnf::cst "token") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "token"))))
Theorem:
(defthm cst-sub-rulename (implies (cst-matchp abnf::cst "sub") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "sub"))))
Theorem:
(defthm cst-white-space-rulename (implies (cst-matchp abnf::cst "white-space") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "white-space"))))
Theorem:
(defthm cst-comment-rulename (implies (cst-matchp abnf::cst "comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "comment"))))
Theorem:
(defthm cst-traditional-comment-rulename (implies (cst-matchp abnf::cst "traditional-comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "traditional-comment"))))
Theorem:
(defthm cst-comment-tail-rulename (implies (cst-matchp abnf::cst "comment-tail") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "comment-tail"))))
Theorem:
(defthm cst-comment-tail-star-rulename (implies (cst-matchp abnf::cst "comment-tail-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "comment-tail-star"))))
Theorem:
(defthm cst-not-star-rulename (implies (cst-matchp abnf::cst "not-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "not-star"))))
Theorem:
(defthm cst-not-star-not-slash-rulename (implies (cst-matchp abnf::cst "not-star-not-slash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "not-star-not-slash"))))
Theorem:
(defthm cst-end-of-line-comment-rulename (implies (cst-matchp abnf::cst "end-of-line-comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "end-of-line-comment"))))
Theorem:
(defthm cst-identifier-rulename (implies (cst-matchp abnf::cst "identifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "identifier"))))
Theorem:
(defthm cst-identifier-chars-rulename (implies (cst-matchp abnf::cst "identifier-chars") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "identifier-chars"))))
Theorem:
(defthm cst-java-letter-rulename (implies (cst-matchp abnf::cst "java-letter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "java-letter"))))
Theorem:
(defthm cst-java-letter-or-digit-rulename (implies (cst-matchp abnf::cst "java-letter-or-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "java-letter-or-digit"))))
Theorem:
(defthm cst-type-identifier-rulename (implies (cst-matchp abnf::cst "type-identifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-identifier"))))
Theorem:
(defthm cst-unqualified-method-identifier-rulename (implies (cst-matchp abnf::cst "unqualified-method-identifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unqualified-method-identifier"))))
Theorem:
(defthm cst-keyword-rulename (implies (cst-matchp abnf::cst "keyword") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "keyword"))))
Theorem:
(defthm cst-literal-rulename (implies (cst-matchp abnf::cst "literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "literal"))))
Theorem:
(defthm cst-integer-literal-rulename (implies (cst-matchp abnf::cst "integer-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "integer-literal"))))
Theorem:
(defthm cst-decimal-integer-literal-rulename (implies (cst-matchp abnf::cst "decimal-integer-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "decimal-integer-literal"))))
Theorem:
(defthm cst-hex-integer-literal-rulename (implies (cst-matchp abnf::cst "hex-integer-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-integer-literal"))))
Theorem:
(defthm cst-octal-integer-literal-rulename (implies (cst-matchp abnf::cst "octal-integer-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-integer-literal"))))
Theorem:
(defthm cst-binary-integer-literal-rulename (implies (cst-matchp abnf::cst "binary-integer-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-integer-literal"))))
Theorem:
(defthm cst-integer-type-suffix-rulename (implies (cst-matchp abnf::cst "integer-type-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "integer-type-suffix"))))
Theorem:
(defthm cst-decimal-numeral-rulename (implies (cst-matchp abnf::cst "decimal-numeral") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "decimal-numeral"))))
Theorem:
(defthm cst-non-zero-digit-rulename (implies (cst-matchp abnf::cst "non-zero-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "non-zero-digit"))))
Theorem:
(defthm cst-digits-rulename (implies (cst-matchp abnf::cst "digits") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digits"))))
Theorem:
(defthm cst-digit-rulename (implies (cst-matchp abnf::cst "digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digit"))))
Theorem:
(defthm cst-digits-and-underscores-rulename (implies (cst-matchp abnf::cst "digits-and-underscores") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digits-and-underscores"))))
Theorem:
(defthm cst-digit-or-underscore-rulename (implies (cst-matchp abnf::cst "digit-or-underscore") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digit-or-underscore"))))
Theorem:
(defthm cst-underscores-rulename (implies (cst-matchp abnf::cst "underscores") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "underscores"))))
Theorem:
(defthm cst-hex-numeral-rulename (implies (cst-matchp abnf::cst "hex-numeral") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-numeral"))))
Theorem:
(defthm cst-hex-digits-rulename (implies (cst-matchp abnf::cst "hex-digits") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-digits"))))
Theorem:
(defthm cst-hex-digits-and-underscores-rulename (implies (cst-matchp abnf::cst "hex-digits-and-underscores") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-digits-and-underscores"))))
Theorem:
(defthm cst-hex-digit-or-underscore-rulename (implies (cst-matchp abnf::cst "hex-digit-or-underscore") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-digit-or-underscore"))))
Theorem:
(defthm cst-octal-numeral-rulename (implies (cst-matchp abnf::cst "octal-numeral") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-numeral"))))
Theorem:
(defthm cst-octal-digits-rulename (implies (cst-matchp abnf::cst "octal-digits") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-digits"))))
Theorem:
(defthm cst-octal-digit-rulename (implies (cst-matchp abnf::cst "octal-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-digit"))))
Theorem:
(defthm cst-octal-digits-and-underscores-rulename (implies (cst-matchp abnf::cst "octal-digits-and-underscores") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-digits-and-underscores"))))
Theorem:
(defthm cst-octal-digit-or-underscore-rulename (implies (cst-matchp abnf::cst "octal-digit-or-underscore") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-digit-or-underscore"))))
Theorem:
(defthm cst-binary-numeral-rulename (implies (cst-matchp abnf::cst "binary-numeral") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-numeral"))))
Theorem:
(defthm cst-binary-digits-rulename (implies (cst-matchp abnf::cst "binary-digits") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-digits"))))
Theorem:
(defthm cst-binary-digit-rulename (implies (cst-matchp abnf::cst "binary-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-digit"))))
Theorem:
(defthm cst-binary-digits-and-underscores-rulename (implies (cst-matchp abnf::cst "binary-digits-and-underscores") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-digits-and-underscores"))))
Theorem:
(defthm cst-binary-digit-or-underscore-rulename (implies (cst-matchp abnf::cst "binary-digit-or-underscore") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-digit-or-underscore"))))
Theorem:
(defthm cst-floating-point-literal-rulename (implies (cst-matchp abnf::cst "floating-point-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "floating-point-literal"))))
Theorem:
(defthm cst-decimal-floating-point-literal-rulename (implies (cst-matchp abnf::cst "decimal-floating-point-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "decimal-floating-point-literal"))))
Theorem:
(defthm cst-exponent-part-rulename (implies (cst-matchp abnf::cst "exponent-part") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exponent-part"))))
Theorem:
(defthm cst-exponent-indicator-rulename (implies (cst-matchp abnf::cst "exponent-indicator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exponent-indicator"))))
Theorem:
(defthm cst-signed-integer-rulename (implies (cst-matchp abnf::cst "signed-integer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "signed-integer"))))
Theorem:
(defthm cst-sign-rulename (implies (cst-matchp abnf::cst "sign") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "sign"))))
Theorem:
(defthm cst-float-type-suffix-rulename (implies (cst-matchp abnf::cst "float-type-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "float-type-suffix"))))
Theorem:
(defthm cst-hexadecimal-floating-point-literal-rulename (implies (cst-matchp abnf::cst "hexadecimal-floating-point-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-floating-point-literal"))))
Theorem:
(defthm cst-hex-significand-rulename (implies (cst-matchp abnf::cst "hex-significand") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-significand"))))
Theorem:
(defthm cst-binary-exponent-rulename (implies (cst-matchp abnf::cst "binary-exponent") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-exponent"))))
Theorem:
(defthm cst-binary-exponent-indicator-rulename (implies (cst-matchp abnf::cst "binary-exponent-indicator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-exponent-indicator"))))
Theorem:
(defthm cst-boolean-literal-rulename (implies (cst-matchp abnf::cst "boolean-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "boolean-literal"))))
Theorem:
(defthm cst-character-literal-rulename (implies (cst-matchp abnf::cst "character-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-literal"))))
Theorem:
(defthm cst-single-character-rulename (implies (cst-matchp abnf::cst "single-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "single-character"))))
Theorem:
(defthm cst-string-literal-rulename (implies (cst-matchp abnf::cst "string-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "string-literal"))))
Theorem:
(defthm cst-string-character-rulename (implies (cst-matchp abnf::cst "string-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "string-character"))))
Theorem:
(defthm cst-escape-sequence-rulename (implies (cst-matchp abnf::cst "escape-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "escape-sequence"))))
Theorem:
(defthm cst-octal-escape-rulename (implies (cst-matchp abnf::cst "octal-escape") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-escape"))))
Theorem:
(defthm cst-zero-to-three-rulename (implies (cst-matchp abnf::cst "zero-to-three") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "zero-to-three"))))
Theorem:
(defthm cst-null-literal-rulename (implies (cst-matchp abnf::cst "null-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "null-literal"))))
Theorem:
(defthm cst-separator-rulename (implies (cst-matchp abnf::cst "separator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "separator"))))
Theorem:
(defthm cst-operator-rulename (implies (cst-matchp abnf::cst "operator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "operator"))))
Theorem:
(defthm cst-type-rulename (implies (cst-matchp abnf::cst "type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type"))))
Theorem:
(defthm cst-primitive-type-rulename (implies (cst-matchp abnf::cst "primitive-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "primitive-type"))))
Theorem:
(defthm cst-numeric-type-rulename (implies (cst-matchp abnf::cst "numeric-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "numeric-type"))))
Theorem:
(defthm cst-integral-type-rulename (implies (cst-matchp abnf::cst "integral-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "integral-type"))))
Theorem:
(defthm cst-floating-point-type-rulename (implies (cst-matchp abnf::cst "floating-point-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "floating-point-type"))))
Theorem:
(defthm cst-reference-type-rulename (implies (cst-matchp abnf::cst "reference-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "reference-type"))))
Theorem:
(defthm cst-class-or-interface-type-rulename (implies (cst-matchp abnf::cst "class-or-interface-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-or-interface-type"))))
Theorem:
(defthm cst-class-type-rulename (implies (cst-matchp abnf::cst "class-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-type"))))
Theorem:
(defthm cst-interface-type-rulename (implies (cst-matchp abnf::cst "interface-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-type"))))
Theorem:
(defthm cst-type-variable-rulename (implies (cst-matchp abnf::cst "type-variable") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-variable"))))
Theorem:
(defthm cst-array-type-rulename (implies (cst-matchp abnf::cst "array-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "array-type"))))
Theorem:
(defthm cst-dims-rulename (implies (cst-matchp abnf::cst "dims") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "dims"))))
Theorem:
(defthm cst-type-parameter-rulename (implies (cst-matchp abnf::cst "type-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-parameter"))))
Theorem:
(defthm cst-type-parameter-modifier-rulename (implies (cst-matchp abnf::cst "type-parameter-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-parameter-modifier"))))
Theorem:
(defthm cst-type-bound-rulename (implies (cst-matchp abnf::cst "type-bound") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-bound"))))
Theorem:
(defthm cst-additional-bound-rulename (implies (cst-matchp abnf::cst "additional-bound") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "additional-bound"))))
Theorem:
(defthm cst-type-arguments-rulename (implies (cst-matchp abnf::cst "type-arguments") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-arguments"))))
Theorem:
(defthm cst-type-argument-list-rulename (implies (cst-matchp abnf::cst "type-argument-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-argument-list"))))
Theorem:
(defthm cst-type-argument-rulename (implies (cst-matchp abnf::cst "type-argument") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-argument"))))
Theorem:
(defthm cst-wildcard-rulename (implies (cst-matchp abnf::cst "wildcard") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "wildcard"))))
Theorem:
(defthm cst-wildcard-bounds-rulename (implies (cst-matchp abnf::cst "wildcard-bounds") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "wildcard-bounds"))))
Theorem:
(defthm cst-module-name-rulename (implies (cst-matchp abnf::cst "module-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "module-name"))))
Theorem:
(defthm cst-package-name-rulename (implies (cst-matchp abnf::cst "package-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "package-name"))))
Theorem:
(defthm cst-type-name-rulename (implies (cst-matchp abnf::cst "type-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-name"))))
Theorem:
(defthm cst-package-or-type-name-rulename (implies (cst-matchp abnf::cst "package-or-type-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "package-or-type-name"))))
Theorem:
(defthm cst-expression-name-rulename (implies (cst-matchp abnf::cst "expression-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "expression-name"))))
Theorem:
(defthm cst-method-name-rulename (implies (cst-matchp abnf::cst "method-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-name"))))
Theorem:
(defthm cst-ambiguous-name-rulename (implies (cst-matchp abnf::cst "ambiguous-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "ambiguous-name"))))
Theorem:
(defthm cst-compilation-unit-rulename (implies (cst-matchp abnf::cst "compilation-unit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "compilation-unit"))))
Theorem:
(defthm cst-ordinary-compilation-unit-rulename (implies (cst-matchp abnf::cst "ordinary-compilation-unit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "ordinary-compilation-unit"))))
Theorem:
(defthm cst-modular-compilation-unit-rulename (implies (cst-matchp abnf::cst "modular-compilation-unit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "modular-compilation-unit"))))
Theorem:
(defthm cst-package-declaration-rulename (implies (cst-matchp abnf::cst "package-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "package-declaration"))))
Theorem:
(defthm cst-package-modifier-rulename (implies (cst-matchp abnf::cst "package-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "package-modifier"))))
Theorem:
(defthm cst-import-declaration-rulename (implies (cst-matchp abnf::cst "import-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "import-declaration"))))
Theorem:
(defthm cst-single-type-import-declaration-rulename (implies (cst-matchp abnf::cst "single-type-import-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "single-type-import-declaration"))))
Theorem:
(defthm cst-type-import-on-demand-declaration-rulename (implies (cst-matchp abnf::cst "type-import-on-demand-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-import-on-demand-declaration"))))
Theorem:
(defthm cst-single-static-import-declaration-rulename (implies (cst-matchp abnf::cst "single-static-import-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "single-static-import-declaration"))))
Theorem:
(defthm cst-static-import-on-demand-declaration-rulename (implies (cst-matchp abnf::cst "static-import-on-demand-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "static-import-on-demand-declaration"))))
Theorem:
(defthm cst-type-declaration-rulename (implies (cst-matchp abnf::cst "type-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-declaration"))))
Theorem:
(defthm cst-module-declaration-rulename (implies (cst-matchp abnf::cst "module-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "module-declaration"))))
Theorem:
(defthm cst-module-directive-rulename (implies (cst-matchp abnf::cst "module-directive") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "module-directive"))))
Theorem:
(defthm cst-requires-modifier-rulename (implies (cst-matchp abnf::cst "requires-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "requires-modifier"))))
Theorem:
(defthm cst-class-declaration-rulename (implies (cst-matchp abnf::cst "class-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-declaration"))))
Theorem:
(defthm cst-normal-class-declaration-rulename (implies (cst-matchp abnf::cst "normal-class-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "normal-class-declaration"))))
Theorem:
(defthm cst-class-modifier-rulename (implies (cst-matchp abnf::cst "class-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-modifier"))))
Theorem:
(defthm cst-type-parameters-rulename (implies (cst-matchp abnf::cst "type-parameters") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-parameters"))))
Theorem:
(defthm cst-type-parameter-list-rulename (implies (cst-matchp abnf::cst "type-parameter-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-parameter-list"))))
Theorem:
(defthm cst-superclass-rulename (implies (cst-matchp abnf::cst "superclass") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "superclass"))))
Theorem:
(defthm cst-superinterfaces-rulename (implies (cst-matchp abnf::cst "superinterfaces") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "superinterfaces"))))
Theorem:
(defthm cst-interface-type-list-rulename (implies (cst-matchp abnf::cst "interface-type-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-type-list"))))
Theorem:
(defthm cst-class-body-rulename (implies (cst-matchp abnf::cst "class-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-body"))))
Theorem:
(defthm cst-class-body-declaration-rulename (implies (cst-matchp abnf::cst "class-body-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-body-declaration"))))
Theorem:
(defthm cst-class-member-declaration-rulename (implies (cst-matchp abnf::cst "class-member-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-member-declaration"))))
Theorem:
(defthm cst-field-declaration-rulename (implies (cst-matchp abnf::cst "field-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "field-declaration"))))
Theorem:
(defthm cst-variable-declarator-list-rulename (implies (cst-matchp abnf::cst "variable-declarator-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-declarator-list"))))
Theorem:
(defthm cst-variable-declarator-rulename (implies (cst-matchp abnf::cst "variable-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-declarator"))))
Theorem:
(defthm cst-variable-declarator-id-rulename (implies (cst-matchp abnf::cst "variable-declarator-id") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-declarator-id"))))
Theorem:
(defthm cst-variable-initializer-rulename (implies (cst-matchp abnf::cst "variable-initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-initializer"))))
Theorem:
(defthm cst-unann-type-rulename (implies (cst-matchp abnf::cst "unann-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-type"))))
Theorem:
(defthm cst-unann-primitive-type-rulename (implies (cst-matchp abnf::cst "unann-primitive-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-primitive-type"))))
Theorem:
(defthm cst-unann-reference-type-rulename (implies (cst-matchp abnf::cst "unann-reference-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-reference-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-rulename (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-class-or-interface-type"))))
Theorem:
(defthm cst-unann-class-type-rulename (implies (cst-matchp abnf::cst "unann-class-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-class-type"))))
Theorem:
(defthm cst-unann-interface-type-rulename (implies (cst-matchp abnf::cst "unann-interface-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-interface-type"))))
Theorem:
(defthm cst-unann-type-variable-rulename (implies (cst-matchp abnf::cst "unann-type-variable") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-type-variable"))))
Theorem:
(defthm cst-unann-array-type-rulename (implies (cst-matchp abnf::cst "unann-array-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unann-array-type"))))
Theorem:
(defthm cst-field-modifier-rulename (implies (cst-matchp abnf::cst "field-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "field-modifier"))))
Theorem:
(defthm cst-method-declaration-rulename (implies (cst-matchp abnf::cst "method-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-declaration"))))
Theorem:
(defthm cst-method-header-rulename (implies (cst-matchp abnf::cst "method-header") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-header"))))
Theorem:
(defthm cst-method-declarator-rulename (implies (cst-matchp abnf::cst "method-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-declarator"))))
Theorem:
(defthm cst-receiver-parameter-rulename (implies (cst-matchp abnf::cst "receiver-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "receiver-parameter"))))
Theorem:
(defthm cst-formal-parameter-list-rulename (implies (cst-matchp abnf::cst "formal-parameter-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "formal-parameter-list"))))
Theorem:
(defthm cst-formal-parameter-rulename (implies (cst-matchp abnf::cst "formal-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "formal-parameter"))))
Theorem:
(defthm cst-variable-arity-parameter-rulename (implies (cst-matchp abnf::cst "variable-arity-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-arity-parameter"))))
Theorem:
(defthm cst-variable-modifier-rulename (implies (cst-matchp abnf::cst "variable-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-modifier"))))
Theorem:
(defthm cst-method-modifier-rulename (implies (cst-matchp abnf::cst "method-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-modifier"))))
Theorem:
(defthm cst-result-rulename (implies (cst-matchp abnf::cst "result") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "result"))))
Theorem:
(defthm cst-throws-rulename (implies (cst-matchp abnf::cst "throws") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "throws"))))
Theorem:
(defthm cst-exception-type-list-rulename (implies (cst-matchp abnf::cst "exception-type-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exception-type-list"))))
Theorem:
(defthm cst-exception-type-rulename (implies (cst-matchp abnf::cst "exception-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exception-type"))))
Theorem:
(defthm cst-method-body-rulename (implies (cst-matchp abnf::cst "method-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-body"))))
Theorem:
(defthm cst-instance-initializer-rulename (implies (cst-matchp abnf::cst "instance-initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "instance-initializer"))))
Theorem:
(defthm cst-static-initializer-rulename (implies (cst-matchp abnf::cst "static-initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "static-initializer"))))
Theorem:
(defthm cst-constructor-declaration-rulename (implies (cst-matchp abnf::cst "constructor-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constructor-declaration"))))
Theorem:
(defthm cst-constructor-declarator-rulename (implies (cst-matchp abnf::cst "constructor-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constructor-declarator"))))
Theorem:
(defthm cst-simple-type-name-rulename (implies (cst-matchp abnf::cst "simple-type-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "simple-type-name"))))
Theorem:
(defthm cst-constructor-modifier-rulename (implies (cst-matchp abnf::cst "constructor-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constructor-modifier"))))
Theorem:
(defthm cst-constructor-body-rulename (implies (cst-matchp abnf::cst "constructor-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constructor-body"))))
Theorem:
(defthm cst-explicit-constructor-invocation-rulename (implies (cst-matchp abnf::cst "explicit-constructor-invocation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "explicit-constructor-invocation"))))
Theorem:
(defthm cst-enum-declaration-rulename (implies (cst-matchp abnf::cst "enum-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-declaration"))))
Theorem:
(defthm cst-enum-body-rulename (implies (cst-matchp abnf::cst "enum-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-body"))))
Theorem:
(defthm cst-enum-constant-list-rulename (implies (cst-matchp abnf::cst "enum-constant-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-constant-list"))))
Theorem:
(defthm cst-enum-constant-rulename (implies (cst-matchp abnf::cst "enum-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-constant"))))
Theorem:
(defthm cst-enum-constant-modifier-rulename (implies (cst-matchp abnf::cst "enum-constant-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-constant-modifier"))))
Theorem:
(defthm cst-enum-body-declarations-rulename (implies (cst-matchp abnf::cst "enum-body-declarations") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-body-declarations"))))
Theorem:
(defthm cst-interface-declaration-rulename (implies (cst-matchp abnf::cst "interface-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-declaration"))))
Theorem:
(defthm cst-normal-interface-declaration-rulename (implies (cst-matchp abnf::cst "normal-interface-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "normal-interface-declaration"))))
Theorem:
(defthm cst-interface-modifier-rulename (implies (cst-matchp abnf::cst "interface-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-modifier"))))
Theorem:
(defthm cst-extends-interfaces-rulename (implies (cst-matchp abnf::cst "extends-interfaces") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "extends-interfaces"))))
Theorem:
(defthm cst-interface-body-rulename (implies (cst-matchp abnf::cst "interface-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-body"))))
Theorem:
(defthm cst-interface-member-declaration-rulename (implies (cst-matchp abnf::cst "interface-member-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-member-declaration"))))
Theorem:
(defthm cst-constant-declaration-rulename (implies (cst-matchp abnf::cst "constant-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constant-declaration"))))
Theorem:
(defthm cst-constant-modifier-rulename (implies (cst-matchp abnf::cst "constant-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constant-modifier"))))
Theorem:
(defthm cst-interface-method-declaration-rulename (implies (cst-matchp abnf::cst "interface-method-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-method-declaration"))))
Theorem:
(defthm cst-interface-method-modifier-rulename (implies (cst-matchp abnf::cst "interface-method-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "interface-method-modifier"))))
Theorem:
(defthm cst-annotation-type-declaration-rulename (implies (cst-matchp abnf::cst "annotation-type-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation-type-declaration"))))
Theorem:
(defthm cst-annotation-type-body-rulename (implies (cst-matchp abnf::cst "annotation-type-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation-type-body"))))
Theorem:
(defthm cst-annotation-type-member-declaration-rulename (implies (cst-matchp abnf::cst "annotation-type-member-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation-type-member-declaration"))))
Theorem:
(defthm cst-annotation-type-element-declaration-rulename (implies (cst-matchp abnf::cst "annotation-type-element-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation-type-element-declaration"))))
Theorem:
(defthm cst-annotation-type-element-modifier-rulename (implies (cst-matchp abnf::cst "annotation-type-element-modifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation-type-element-modifier"))))
Theorem:
(defthm cst-default-value-rulename (implies (cst-matchp abnf::cst "default-value") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "default-value"))))
Theorem:
(defthm cst-annotation-rulename (implies (cst-matchp abnf::cst "annotation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "annotation"))))
Theorem:
(defthm cst-normal-annotation-rulename (implies (cst-matchp abnf::cst "normal-annotation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "normal-annotation"))))
Theorem:
(defthm cst-element-value-pair-list-rulename (implies (cst-matchp abnf::cst "element-value-pair-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "element-value-pair-list"))))
Theorem:
(defthm cst-element-value-pair-rulename (implies (cst-matchp abnf::cst "element-value-pair") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "element-value-pair"))))
Theorem:
(defthm cst-element-value-rulename (implies (cst-matchp abnf::cst "element-value") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "element-value"))))
Theorem:
(defthm cst-element-value-array-initializer-rulename (implies (cst-matchp abnf::cst "element-value-array-initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "element-value-array-initializer"))))
Theorem:
(defthm cst-element-value-list-rulename (implies (cst-matchp abnf::cst "element-value-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "element-value-list"))))
Theorem:
(defthm cst-marker-annotation-rulename (implies (cst-matchp abnf::cst "marker-annotation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "marker-annotation"))))
Theorem:
(defthm cst-single-element-annotation-rulename (implies (cst-matchp abnf::cst "single-element-annotation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "single-element-annotation"))))
Theorem:
(defthm cst-array-initializer-rulename (implies (cst-matchp abnf::cst "array-initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "array-initializer"))))
Theorem:
(defthm cst-variable-initializer-list-rulename (implies (cst-matchp abnf::cst "variable-initializer-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-initializer-list"))))
Theorem:
(defthm cst-block-rulename (implies (cst-matchp abnf::cst "block") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block"))))
Theorem:
(defthm cst-block-statements-rulename (implies (cst-matchp abnf::cst "block-statements") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block-statements"))))
Theorem:
(defthm cst-block-statement-rulename (implies (cst-matchp abnf::cst "block-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block-statement"))))
Theorem:
(defthm cst-local-variable-declaration-statement-rulename (implies (cst-matchp abnf::cst "local-variable-declaration-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "local-variable-declaration-statement"))))
Theorem:
(defthm cst-local-variable-declaration-rulename (implies (cst-matchp abnf::cst "local-variable-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "local-variable-declaration"))))
Theorem:
(defthm cst-local-variable-type-rulename (implies (cst-matchp abnf::cst "local-variable-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "local-variable-type"))))
Theorem:
(defthm cst-statement-rulename (implies (cst-matchp abnf::cst "statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "statement"))))
Theorem:
(defthm cst-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "statement-no-short-if"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-rulename (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-empty-statement-rulename (implies (cst-matchp abnf::cst "empty-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "empty-statement"))))
Theorem:
(defthm cst-labeled-statement-rulename (implies (cst-matchp abnf::cst "labeled-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "labeled-statement"))))
Theorem:
(defthm cst-labeled-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "labeled-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "labeled-statement-no-short-if"))))
Theorem:
(defthm cst-expression-statement-rulename (implies (cst-matchp abnf::cst "expression-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "expression-statement"))))
Theorem:
(defthm cst-statement-expression-rulename (implies (cst-matchp abnf::cst "statement-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "statement-expression"))))
Theorem:
(defthm cst-if-then-statement-rulename (implies (cst-matchp abnf::cst "if-then-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "if-then-statement"))))
Theorem:
(defthm cst-if-then-else-statement-rulename (implies (cst-matchp abnf::cst "if-then-else-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "if-then-else-statement"))))
Theorem:
(defthm cst-if-then-else-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "if-then-else-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "if-then-else-statement-no-short-if"))))
Theorem:
(defthm cst-assert-statement-rulename (implies (cst-matchp abnf::cst "assert-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "assert-statement"))))
Theorem:
(defthm cst-switch-statement-rulename (implies (cst-matchp abnf::cst "switch-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-statement"))))
Theorem:
(defthm cst-switch-block-rulename (implies (cst-matchp abnf::cst "switch-block") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-block"))))
Theorem:
(defthm cst-switch-rule-rulename (implies (cst-matchp abnf::cst "switch-rule") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-rule"))))
Theorem:
(defthm cst-switch-block-statement-group-rulename (implies (cst-matchp abnf::cst "switch-block-statement-group") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-block-statement-group"))))
Theorem:
(defthm cst-switch-label-rulename (implies (cst-matchp abnf::cst "switch-label") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-label"))))
Theorem:
(defthm cst-case-constant-rulename (implies (cst-matchp abnf::cst "case-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "case-constant"))))
Theorem:
(defthm cst-while-statement-rulename (implies (cst-matchp abnf::cst "while-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "while-statement"))))
Theorem:
(defthm cst-while-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "while-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "while-statement-no-short-if"))))
Theorem:
(defthm cst-do-statement-rulename (implies (cst-matchp abnf::cst "do-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "do-statement"))))
Theorem:
(defthm cst-for-statement-rulename (implies (cst-matchp abnf::cst "for-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "for-statement"))))
Theorem:
(defthm cst-for-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "for-statement-no-short-if"))))
Theorem:
(defthm cst-basic-for-statement-rulename (implies (cst-matchp abnf::cst "basic-for-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-for-statement"))))
Theorem:
(defthm cst-basic-for-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "basic-for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-init-rulename (implies (cst-matchp abnf::cst "for-init") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "for-init"))))
Theorem:
(defthm cst-for-update-rulename (implies (cst-matchp abnf::cst "for-update") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "for-update"))))
Theorem:
(defthm cst-statement-expression-list-rulename (implies (cst-matchp abnf::cst "statement-expression-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "statement-expression-list"))))
Theorem:
(defthm cst-enhanced-for-statement-rulename (implies (cst-matchp abnf::cst "enhanced-for-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enhanced-for-statement"))))
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-rulename (implies (cst-matchp abnf::cst "enhanced-for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enhanced-for-statement-no-short-if"))))
Theorem:
(defthm cst-break-statement-rulename (implies (cst-matchp abnf::cst "break-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "break-statement"))))
Theorem:
(defthm cst-continue-statement-rulename (implies (cst-matchp abnf::cst "continue-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "continue-statement"))))
Theorem:
(defthm cst-return-statement-rulename (implies (cst-matchp abnf::cst "return-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "return-statement"))))
Theorem:
(defthm cst-throw-statement-rulename (implies (cst-matchp abnf::cst "throw-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "throw-statement"))))
Theorem:
(defthm cst-synchronized-statement-rulename (implies (cst-matchp abnf::cst "synchronized-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "synchronized-statement"))))
Theorem:
(defthm cst-try-statement-rulename (implies (cst-matchp abnf::cst "try-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "try-statement"))))
Theorem:
(defthm cst-catches-rulename (implies (cst-matchp abnf::cst "catches") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "catches"))))
Theorem:
(defthm cst-catch-clause-rulename (implies (cst-matchp abnf::cst "catch-clause") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "catch-clause"))))
Theorem:
(defthm cst-catch-formal-parameter-rulename (implies (cst-matchp abnf::cst "catch-formal-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "catch-formal-parameter"))))
Theorem:
(defthm cst-catch-type-rulename (implies (cst-matchp abnf::cst "catch-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "catch-type"))))
Theorem:
(defthm cst-finally-rulename (implies (cst-matchp abnf::cst "finally") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "finally"))))
Theorem:
(defthm cst-try-with-resources-statement-rulename (implies (cst-matchp abnf::cst "try-with-resources-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "try-with-resources-statement"))))
Theorem:
(defthm cst-resource-specification-rulename (implies (cst-matchp abnf::cst "resource-specification") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "resource-specification"))))
Theorem:
(defthm cst-resource-list-rulename (implies (cst-matchp abnf::cst "resource-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "resource-list"))))
Theorem:
(defthm cst-resource-rulename (implies (cst-matchp abnf::cst "resource") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "resource"))))
Theorem:
(defthm cst-variable-access-rulename (implies (cst-matchp abnf::cst "variable-access") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "variable-access"))))
Theorem:
(defthm cst-yield-statement-rulename (implies (cst-matchp abnf::cst "yield-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "yield-statement"))))
Theorem:
(defthm cst-expression-rulename (implies (cst-matchp abnf::cst "expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "expression"))))
Theorem:
(defthm cst-primary-rulename (implies (cst-matchp abnf::cst "primary") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "primary"))))
Theorem:
(defthm cst-primary-no-new-array-rulename (implies (cst-matchp abnf::cst "primary-no-new-array") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "primary-no-new-array"))))
Theorem:
(defthm cst-class-literal-rulename (implies (cst-matchp abnf::cst "class-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-literal"))))
Theorem:
(defthm cst-class-instance-creation-expression-rulename (implies (cst-matchp abnf::cst "class-instance-creation-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-instance-creation-expression"))))
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-rulename (implies (cst-matchp abnf::cst "unqualified-class-instance-creation-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unqualified-class-instance-creation-expression"))))
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-rulename (implies (cst-matchp abnf::cst "class-or-interface-type-to-instantiate") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "class-or-interface-type-to-instantiate"))))
Theorem:
(defthm cst-type-arguments-or-diamond-rulename (implies (cst-matchp abnf::cst "type-arguments-or-diamond") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-arguments-or-diamond"))))
Theorem:
(defthm cst-array-creation-expression-rulename (implies (cst-matchp abnf::cst "array-creation-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "array-creation-expression"))))
Theorem:
(defthm cst-dim-exprs-rulename (implies (cst-matchp abnf::cst "dim-exprs") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "dim-exprs"))))
Theorem:
(defthm cst-dim-expr-rulename (implies (cst-matchp abnf::cst "dim-expr") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "dim-expr"))))
Theorem:
(defthm cst-array-access-rulename (implies (cst-matchp abnf::cst "array-access") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "array-access"))))
Theorem:
(defthm cst-field-access-rulename (implies (cst-matchp abnf::cst "field-access") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "field-access"))))
Theorem:
(defthm cst-method-invocation-rulename (implies (cst-matchp abnf::cst "method-invocation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-invocation"))))
Theorem:
(defthm cst-argument-list-rulename (implies (cst-matchp abnf::cst "argument-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "argument-list"))))
Theorem:
(defthm cst-method-reference-rulename (implies (cst-matchp abnf::cst "method-reference") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "method-reference"))))
Theorem:
(defthm cst-postfix-expression-rulename (implies (cst-matchp abnf::cst "postfix-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "postfix-expression"))))
Theorem:
(defthm cst-post-increment-expression-rulename (implies (cst-matchp abnf::cst "post-increment-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "post-increment-expression"))))
Theorem:
(defthm cst-post-decrement-expression-rulename (implies (cst-matchp abnf::cst "post-decrement-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "post-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-rulename (implies (cst-matchp abnf::cst "unary-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unary-expression"))))
Theorem:
(defthm cst-pre-increment-expression-rulename (implies (cst-matchp abnf::cst "pre-increment-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "pre-increment-expression"))))
Theorem:
(defthm cst-pre-decrement-expression-rulename (implies (cst-matchp abnf::cst "pre-decrement-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "pre-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-rulename (implies (cst-matchp abnf::cst "unary-expression-not-plus-minus") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unary-expression-not-plus-minus"))))
Theorem:
(defthm cst-cast-expression-rulename (implies (cst-matchp abnf::cst "cast-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "cast-expression"))))
Theorem:
(defthm cst-multiplicative-expression-rulename (implies (cst-matchp abnf::cst "multiplicative-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "multiplicative-expression"))))
Theorem:
(defthm cst-additive-expression-rulename (implies (cst-matchp abnf::cst "additive-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "additive-expression"))))
Theorem:
(defthm cst-shift-expression-rulename (implies (cst-matchp abnf::cst "shift-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "shift-expression"))))
Theorem:
(defthm cst-relational-expression-rulename (implies (cst-matchp abnf::cst "relational-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "relational-expression"))))
Theorem:
(defthm cst-equality-expression-rulename (implies (cst-matchp abnf::cst "equality-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "equality-expression"))))
Theorem:
(defthm cst-and-expression-rulename (implies (cst-matchp abnf::cst "and-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "and-expression"))))
Theorem:
(defthm cst-exclusive-or-expression-rulename (implies (cst-matchp abnf::cst "exclusive-or-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exclusive-or-expression"))))
Theorem:
(defthm cst-inclusive-or-expression-rulename (implies (cst-matchp abnf::cst "inclusive-or-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "inclusive-or-expression"))))
Theorem:
(defthm cst-conditional-and-expression-rulename (implies (cst-matchp abnf::cst "conditional-and-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "conditional-and-expression"))))
Theorem:
(defthm cst-conditional-or-expression-rulename (implies (cst-matchp abnf::cst "conditional-or-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "conditional-or-expression"))))
Theorem:
(defthm cst-conditional-expression-rulename (implies (cst-matchp abnf::cst "conditional-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "conditional-expression"))))
Theorem:
(defthm cst-assignment-expression-rulename (implies (cst-matchp abnf::cst "assignment-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "assignment-expression"))))
Theorem:
(defthm cst-assignment-rulename (implies (cst-matchp abnf::cst "assignment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "assignment"))))
Theorem:
(defthm cst-left-hand-side-rulename (implies (cst-matchp abnf::cst "left-hand-side") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "left-hand-side"))))
Theorem:
(defthm cst-assignment-operator-rulename (implies (cst-matchp abnf::cst "assignment-operator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "assignment-operator"))))
Theorem:
(defthm cst-lambda-expression-rulename (implies (cst-matchp abnf::cst "lambda-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-expression"))))
Theorem:
(defthm cst-lambda-parameters-rulename (implies (cst-matchp abnf::cst "lambda-parameters") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-parameters"))))
Theorem:
(defthm cst-lambda-parameter-list-rulename (implies (cst-matchp abnf::cst "lambda-parameter-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-parameter-list"))))
Theorem:
(defthm cst-lambda-parameter-rulename (implies (cst-matchp abnf::cst "lambda-parameter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-parameter"))))
Theorem:
(defthm cst-lambda-parameter-type-rulename (implies (cst-matchp abnf::cst "lambda-parameter-type") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-parameter-type"))))
Theorem:
(defthm cst-lambda-body-rulename (implies (cst-matchp abnf::cst "lambda-body") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lambda-body"))))
Theorem:
(defthm cst-switch-expression-rulename (implies (cst-matchp abnf::cst "switch-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "switch-expression"))))
Theorem:
(defthm cst-constant-expression-rulename (implies (cst-matchp abnf::cst "constant-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constant-expression"))))
Theorem:
(defthm cst-unicode-input-character-branches-match-alt (implies (cst-matchp abnf::cst "unicode-input-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unicode-escape / raw-input-character")))
Theorem:
(defthm cst-unicode-escape-branches-match-alt (implies (cst-matchp abnf::cst "unicode-escape") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit")))
Theorem:
(defthm cst-unicode-marker-branches-match-alt (implies (cst-matchp abnf::cst "unicode-marker") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*%s\"u\"")))
Theorem:
(defthm cst-hex-digit-branches-match-alt (implies (cst-matchp abnf::cst "hex-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")))
Theorem:
(defthm cst-raw-input-character-branches-match-alt (implies (cst-matchp abnf::cst "raw-input-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x0-FFFF")))
Theorem:
(defthm cst-line-terminator-branches-match-alt (implies (cst-matchp abnf::cst "line-terminator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%d10 / %d13 / %d13.10")))
Theorem:
(defthm cst-input-character-branches-match-alt (implies (cst-matchp abnf::cst "input-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unicode-input-character")))
Theorem:
(defthm cst-input-branches-match-alt (implies (cst-matchp abnf::cst "input") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*input-element [ sub ]")))
Theorem:
(defthm cst-input-element-branches-match-alt (implies (cst-matchp abnf::cst "input-element") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "white-space / comment / token")))
Theorem:
(defthm cst-token-branches-match-alt (implies (cst-matchp abnf::cst "token") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / keyword / literal / separator / operator")))
Theorem:
(defthm cst-sub-branches-match-alt (implies (cst-matchp abnf::cst "sub") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%d26")))
Theorem:
(defthm cst-white-space-branches-match-alt (implies (cst-matchp abnf::cst "white-space") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%d32 / %d9 / %d12 / line-terminator")))
Theorem:
(defthm cst-comment-branches-match-alt (implies (cst-matchp abnf::cst "comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "traditional-comment / end-of-line-comment")))
Theorem:
(defthm cst-traditional-comment-branches-match-alt (implies (cst-matchp abnf::cst "traditional-comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"/\" \"*\" comment-tail")))
Theorem:
(defthm cst-comment-tail-branches-match-alt (implies (cst-matchp abnf::cst "comment-tail") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"*\" comment-tail-star / not-star comment-tail")))
Theorem:
(defthm cst-comment-tail-star-branches-match-alt (implies (cst-matchp abnf::cst "comment-tail-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"/\" / \"*\" comment-tail-star / not-star-not-slash comment-tail")))
Theorem:
(defthm cst-not-star-branches-match-alt (implies (cst-matchp abnf::cst "not-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character / line-terminator")))
Theorem:
(defthm cst-not-star-not-slash-branches-match-alt (implies (cst-matchp abnf::cst "not-star-not-slash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character / line-terminator")))
Theorem:
(defthm cst-end-of-line-comment-branches-match-alt (implies (cst-matchp abnf::cst "end-of-line-comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"/\" \"/\" *input-character")))
Theorem:
(defthm cst-identifier-branches-match-alt (implies (cst-matchp abnf::cst "identifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier-chars")))
Theorem:
(defthm cst-identifier-chars-branches-match-alt (implies (cst-matchp abnf::cst "identifier-chars") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "java-letter *java-letter-or-digit")))
Theorem:
(defthm cst-java-letter-branches-match-alt (implies (cst-matchp abnf::cst "java-letter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "raw-input-character")))
Theorem:
(defthm cst-java-letter-or-digit-branches-match-alt (implies (cst-matchp abnf::cst "java-letter-or-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "raw-input-character")))
Theorem:
(defthm cst-type-identifier-branches-match-alt (implies (cst-matchp abnf::cst "type-identifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier")))
Theorem:
(defthm cst-unqualified-method-identifier-branches-match-alt (implies (cst-matchp abnf::cst "unqualified-method-identifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier")))
Theorem:
(defthm cst-keyword-branches-match-alt (implies (cst-matchp abnf::cst "keyword") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"abstract\" / %s\"assert\" / %s\"boolean\" / %s\"break\" / %s\"byte\" / %s\"case\" / %s\"catch\" / %s\"char\" / %s\"class\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extends\" / %s\"final\" / %s\"finally\" / %s\"float\" / %s\"for\" / %s\"if\" / %s\"goto\" / %s\"implements\" / %s\"import\" / %s\"instanceof\" / %s\"int\" / %s\"interface\" / %s\"long\" / %s\"native\" / %s\"new\" / %s\"package\" / %s\"private\" / %s\"protected\" / %s\"public\" / %s\"return\" / %s\"short\" / %s\"static\" / %s\"strictfp\" / %s\"super\" / %s\"switch\" / %s\"synchronized\" / %s\"this\" / %s\"throw\" / %s\"throws\" / %s\"transient\" / %s\"try\" / %s\"void\" / %s\"volatile\" / %s\"while\" / \"_\"")))
Theorem:
(defthm cst-literal-branches-match-alt (implies (cst-matchp abnf::cst "literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-literal / floating-point-literal / boolean-literal / character-literal / string-literal / null-literal")))
Theorem:
(defthm cst-integer-literal-branches-match-alt (implies (cst-matchp abnf::cst "integer-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-integer-literal / hex-integer-literal / octal-integer-literal / binary-integer-literal")))
Theorem:
(defthm cst-decimal-integer-literal-branches-match-alt (implies (cst-matchp abnf::cst "decimal-integer-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-numeral [ integer-type-suffix ]")))
Theorem:
(defthm cst-hex-integer-literal-branches-match-alt (implies (cst-matchp abnf::cst "hex-integer-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-numeral [ integer-type-suffix ]")))
Theorem:
(defthm cst-octal-integer-literal-branches-match-alt (implies (cst-matchp abnf::cst "octal-integer-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-numeral [ integer-type-suffix ]")))
Theorem:
(defthm cst-binary-integer-literal-branches-match-alt (implies (cst-matchp abnf::cst "binary-integer-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-numeral [ integer-type-suffix ]")))
Theorem:
(defthm cst-integer-type-suffix-branches-match-alt (implies (cst-matchp abnf::cst "integer-type-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"l\"")))
Theorem:
(defthm cst-decimal-numeral-branches-match-alt (implies (cst-matchp abnf::cst "decimal-numeral") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / non-zero-digit [ digits ] / non-zero-digit underscores digits")))
Theorem:
(defthm cst-non-zero-digit-branches-match-alt (implies (cst-matchp abnf::cst "non-zero-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"")))
Theorem:
(defthm cst-digits-branches-match-alt (implies (cst-matchp abnf::cst "digits") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit / digit [ digits-and-underscores ] digit")))
Theorem:
(defthm cst-digit-branches-match-alt (implies (cst-matchp abnf::cst "digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / non-zero-digit")))
Theorem:
(defthm cst-digits-and-underscores-branches-match-alt (implies (cst-matchp abnf::cst "digits-and-underscores") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit-or-underscore *digit-or-underscore")))
Theorem:
(defthm cst-digit-or-underscore-branches-match-alt (implies (cst-matchp abnf::cst "digit-or-underscore") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit / \"_\"")))
Theorem:
(defthm cst-underscores-branches-match-alt (implies (cst-matchp abnf::cst "underscores") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*\"_\"")))
Theorem:
(defthm cst-hex-numeral-branches-match-alt (implies (cst-matchp abnf::cst "hex-numeral") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0x\" hex-digits")))
Theorem:
(defthm cst-hex-digits-branches-match-alt (implies (cst-matchp abnf::cst "hex-digits") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-digit / hex-digit [ hex-digits-and-underscores ] hex-digit")))
Theorem:
(defthm cst-hex-digits-and-underscores-branches-match-alt (implies (cst-matchp abnf::cst "hex-digits-and-underscores") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*hex-digit-or-underscore")))
Theorem:
(defthm cst-hex-digit-or-underscore-branches-match-alt (implies (cst-matchp abnf::cst "hex-digit-or-underscore") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-digit / \"_\"")))
Theorem:
(defthm cst-octal-numeral-branches-match-alt (implies (cst-matchp abnf::cst "octal-numeral") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" octal-digits / \"0\" underscores octal-digits")))
Theorem:
(defthm cst-octal-digits-branches-match-alt (implies (cst-matchp abnf::cst "octal-digits") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-digit / octal-digit [ octal-digits-and-underscores ] octal-digit")))
Theorem:
(defthm cst-octal-digit-branches-match-alt (implies (cst-matchp abnf::cst "octal-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\"")))
Theorem:
(defthm cst-octal-digits-and-underscores-branches-match-alt (implies (cst-matchp abnf::cst "octal-digits-and-underscores") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*octal-digit-or-underscore")))
Theorem:
(defthm cst-octal-digit-or-underscore-branches-match-alt (implies (cst-matchp abnf::cst "octal-digit-or-underscore") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-digit / \"_\"")))
Theorem:
(defthm cst-binary-numeral-branches-match-alt (implies (cst-matchp abnf::cst "binary-numeral") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0b\" binary-digits")))
Theorem:
(defthm cst-binary-digits-branches-match-alt (implies (cst-matchp abnf::cst "binary-digits") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-digit / binary-digit [ binary-digits-and-underscores ] binary-digit")))
Theorem:
(defthm cst-binary-digit-branches-match-alt (implies (cst-matchp abnf::cst "binary-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / \"1\"")))
Theorem:
(defthm cst-binary-digits-and-underscores-branches-match-alt (implies (cst-matchp abnf::cst "binary-digits-and-underscores") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*binary-digit-or-underscore")))
Theorem:
(defthm cst-binary-digit-or-underscore-branches-match-alt (implies (cst-matchp abnf::cst "binary-digit-or-underscore") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-digit / \"_\"")))
Theorem:
(defthm cst-floating-point-literal-branches-match-alt (implies (cst-matchp abnf::cst "floating-point-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-point-literal / hexadecimal-floating-point-literal")))
Theorem:
(defthm cst-decimal-floating-point-literal-branches-match-alt (implies (cst-matchp abnf::cst "decimal-floating-point-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ] / \".\" digits [ exponent-part ] [ float-type-suffix ] / digits exponent-part [ float-type-suffix ] / digits [ exponent-part ] float-type-suffix")))
Theorem:
(defthm cst-exponent-part-branches-match-alt (implies (cst-matchp abnf::cst "exponent-part") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "exponent-indicator signed-integer")))
Theorem:
(defthm cst-exponent-indicator-branches-match-alt (implies (cst-matchp abnf::cst "exponent-indicator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"e\"")))
Theorem:
(defthm cst-signed-integer-branches-match-alt (implies (cst-matchp abnf::cst "signed-integer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ sign ] digits")))
Theorem:
(defthm cst-sign-branches-match-alt (implies (cst-matchp abnf::cst "sign") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"+\" / \"-\"")))
Theorem:
(defthm cst-float-type-suffix-branches-match-alt (implies (cst-matchp abnf::cst "float-type-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"f\" / \"d\"")))
Theorem:
(defthm cst-hexadecimal-floating-point-literal-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-floating-point-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-significand binary-exponent [ float-type-suffix ]")))
Theorem:
(defthm cst-hex-significand-branches-match-alt (implies (cst-matchp abnf::cst "hex-significand") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-numeral [ \".\" ] / \"0x\" [ hex-digits ] \".\" hex-digits")))
Theorem:
(defthm cst-binary-exponent-branches-match-alt (implies (cst-matchp abnf::cst "binary-exponent") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-exponent-indicator signed-integer")))
Theorem:
(defthm cst-binary-exponent-indicator-branches-match-alt (implies (cst-matchp abnf::cst "binary-exponent-indicator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"p\"")))
Theorem:
(defthm cst-boolean-literal-branches-match-alt (implies (cst-matchp abnf::cst "boolean-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"true\" / %s\"false\"")))
Theorem:
(defthm cst-character-literal-branches-match-alt (implies (cst-matchp abnf::cst "character-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"'\" single-character \"'\" / \"'\" escape-sequence \"'\"")))
Theorem:
(defthm cst-single-character-branches-match-alt (implies (cst-matchp abnf::cst "single-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character")))
Theorem:
(defthm cst-string-literal-branches-match-alt (implies (cst-matchp abnf::cst "string-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%d34 *string-character %d34")))
Theorem:
(defthm cst-string-character-branches-match-alt (implies (cst-matchp abnf::cst "string-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character / escape-sequence")))
Theorem:
(defthm cst-escape-sequence-branches-match-alt (implies (cst-matchp abnf::cst "escape-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"\\b\" / %s\"\\t\" / %s\"\\n\" / %s\"\\f\" / %s\"\\r\" / \"\\\" %d34 / \"\\'\" / \"\\\\\" / octal-escape")))
Theorem:
(defthm cst-octal-escape-branches-match-alt (implies (cst-matchp abnf::cst "octal-escape") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" zero-to-three octal-digit octal-digit")))
Theorem:
(defthm cst-zero-to-three-branches-match-alt (implies (cst-matchp abnf::cst "zero-to-three") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / \"1\" / \"2\"")))
Theorem:
(defthm cst-null-literal-branches-match-alt (implies (cst-matchp abnf::cst "null-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"null\"")))
Theorem:
(defthm cst-separator-branches-match-alt (implies (cst-matchp abnf::cst "separator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" / \")\" / \"{\" / \"}\" / \"[\" / \"]\" / \";\" / \",\" / \".\" / \"...\" / \"@\" / \"::\"")))
Theorem:
(defthm cst-operator-branches-match-alt (implies (cst-matchp abnf::cst "operator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"=\" / \">\" / \"<\" / \"!\" / \"~\" / \"?\" / \":\" / \"->\" / \"==\" / \">=\" / \"<=\" / \"!=\" / \"&&\" / \"||\" / \"++\" / \"--\" / \"+\" / \"-\" / \"*\" / \"/\" / \"&\" / \"|\" / \"^\" / \"%\" / \"<<\" / \">>\" / \">>>\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"&=\" / \"|=\" / \"^=\" / \"%=\" / \"<<=\" / \">>=\" / \">>>=\"")))
Theorem:
(defthm cst-type-branches-match-alt (implies (cst-matchp abnf::cst "type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "primitive-type / reference-type")))
Theorem:
(defthm cst-primitive-type-branches-match-alt (implies (cst-matchp abnf::cst "primitive-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation numeric-type / *annotation %s\"boolean\"")))
Theorem:
(defthm cst-numeric-type-branches-match-alt (implies (cst-matchp abnf::cst "numeric-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "integral-type / floating-point-type")))
Theorem:
(defthm cst-integral-type-branches-match-alt (implies (cst-matchp abnf::cst "integral-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"byte\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"char\"")))
Theorem:
(defthm cst-floating-point-type-branches-match-alt (implies (cst-matchp abnf::cst "floating-point-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"float\" / %s\"double\"")))
Theorem:
(defthm cst-reference-type-branches-match-alt (implies (cst-matchp abnf::cst "reference-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-or-interface-type / type-variable / array-type")))
Theorem:
(defthm cst-class-or-interface-type-branches-match-alt (implies (cst-matchp abnf::cst "class-or-interface-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type / interface-type")))
Theorem:
(defthm cst-class-type-branches-match-alt (implies (cst-matchp abnf::cst "class-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")))
Theorem:
(defthm cst-interface-type-branches-match-alt (implies (cst-matchp abnf::cst "interface-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type")))
Theorem:
(defthm cst-type-variable-branches-match-alt (implies (cst-matchp abnf::cst "type-variable") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation type-identifier")))
Theorem:
(defthm cst-array-type-branches-match-alt (implies (cst-matchp abnf::cst "array-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "primitive-type dims / class-or-interface-type dims / type-variable dims")))
Theorem:
(defthm cst-dims-branches-match-alt (implies (cst-matchp abnf::cst "dims") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*( *annotation \"[\" \"]\" )")))
Theorem:
(defthm cst-type-parameter-branches-match-alt (implies (cst-matchp abnf::cst "type-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*type-parameter-modifier type-identifier [ type-bound ]")))
Theorem:
(defthm cst-type-parameter-modifier-branches-match-alt (implies (cst-matchp abnf::cst "type-parameter-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation")))
Theorem:
(defthm cst-type-bound-branches-match-alt (implies (cst-matchp abnf::cst "type-bound") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"extends\" type-variable / %s\"extends\" class-or-interface-type *additional-bound")))
Theorem:
(defthm cst-additional-bound-branches-match-alt (implies (cst-matchp abnf::cst "additional-bound") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"&\" interface-type")))
Theorem:
(defthm cst-type-arguments-branches-match-alt (implies (cst-matchp abnf::cst "type-arguments") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"<\" type-argument-list \">\"")))
Theorem:
(defthm cst-type-argument-list-branches-match-alt (implies (cst-matchp abnf::cst "type-argument-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-argument *( \",\" type-argument )")))
Theorem:
(defthm cst-type-argument-branches-match-alt (implies (cst-matchp abnf::cst "type-argument") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "reference-type / wildcard")))
Theorem:
(defthm cst-wildcard-branches-match-alt (implies (cst-matchp abnf::cst "wildcard") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation \"?\" [ wildcard-bounds ]")))
Theorem:
(defthm cst-wildcard-bounds-branches-match-alt (implies (cst-matchp abnf::cst "wildcard-bounds") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"extends\" reference-type / %s\"super\" reference-type")))
Theorem:
(defthm cst-module-name-branches-match-alt (implies (cst-matchp abnf::cst "module-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / module-name \".\" identifier")))
Theorem:
(defthm cst-package-name-branches-match-alt (implies (cst-matchp abnf::cst "package-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / package-name \".\" identifier")))
Theorem:
(defthm cst-type-name-branches-match-alt (implies (cst-matchp abnf::cst "type-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-identifier / package-or-type-name \".\" type-identifier")))
Theorem:
(defthm cst-package-or-type-name-branches-match-alt (implies (cst-matchp abnf::cst "package-or-type-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / package-or-type-name \".\" identifier")))
Theorem:
(defthm cst-expression-name-branches-match-alt (implies (cst-matchp abnf::cst "expression-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / ambiguous-name \".\" identifier")))
Theorem:
(defthm cst-method-name-branches-match-alt (implies (cst-matchp abnf::cst "method-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unqualified-method-identifier")))
Theorem:
(defthm cst-ambiguous-name-branches-match-alt (implies (cst-matchp abnf::cst "ambiguous-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / ambiguous-name \".\" identifier")))
Theorem:
(defthm cst-compilation-unit-branches-match-alt (implies (cst-matchp abnf::cst "compilation-unit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "ordinary-compilation-unit / modular-compilation-unit")))
Theorem:
(defthm cst-ordinary-compilation-unit-branches-match-alt (implies (cst-matchp abnf::cst "ordinary-compilation-unit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ package-declaration ] *import-declaration *type-declaration")))
Theorem:
(defthm cst-modular-compilation-unit-branches-match-alt (implies (cst-matchp abnf::cst "modular-compilation-unit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*import-declaration module-declaration")))
Theorem:
(defthm cst-package-declaration-branches-match-alt (implies (cst-matchp abnf::cst "package-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\"")))
Theorem:
(defthm cst-package-modifier-branches-match-alt (implies (cst-matchp abnf::cst "package-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation")))
Theorem:
(defthm cst-import-declaration-branches-match-alt (implies (cst-matchp abnf::cst "import-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-type-import-declaration / type-import-on-demand-declaration / single-static-import-declaration / static-import-on-demand-declaration")))
Theorem:
(defthm cst-single-type-import-declaration-branches-match-alt (implies (cst-matchp abnf::cst "single-type-import-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"import\" type-name \";\"")))
Theorem:
(defthm cst-type-import-on-demand-declaration-branches-match-alt (implies (cst-matchp abnf::cst "type-import-on-demand-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"import\" package-or-type-name \".\" \"*\" \";\"")))
Theorem:
(defthm cst-single-static-import-declaration-branches-match-alt (implies (cst-matchp abnf::cst "single-static-import-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"import\" %s\"static\" type-name \".\" identifier \";\"")))
Theorem:
(defthm cst-static-import-on-demand-declaration-branches-match-alt (implies (cst-matchp abnf::cst "static-import-on-demand-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\"")))
Theorem:
(defthm cst-type-declaration-branches-match-alt (implies (cst-matchp abnf::cst "type-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-declaration / interface-declaration / \";\"")))
Theorem:
(defthm cst-module-declaration-branches-match-alt (implies (cst-matchp abnf::cst "module-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\"")))
Theorem:
(defthm cst-module-directive-branches-match-alt (implies (cst-matchp abnf::cst "module-directive") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"requires\" *requires-modifier module-name \";\" / %s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"uses\" type-name \";\" / %s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\"")))
Theorem:
(defthm cst-requires-modifier-branches-match-alt (implies (cst-matchp abnf::cst "requires-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"transitive\" / %s\"static\"")))
Theorem:
(defthm cst-class-declaration-branches-match-alt (implies (cst-matchp abnf::cst "class-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-class-declaration / enum-declaration")))
Theorem:
(defthm cst-normal-class-declaration-branches-match-alt (implies (cst-matchp abnf::cst "normal-class-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ superclass ] [ superinterfaces ] class-body")))
Theorem:
(defthm cst-class-modifier-branches-match-alt (implies (cst-matchp abnf::cst "class-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"strictfp\"")))
Theorem:
(defthm cst-type-parameters-branches-match-alt (implies (cst-matchp abnf::cst "type-parameters") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"<\" type-parameter-list \">\"")))
Theorem:
(defthm cst-type-parameter-list-branches-match-alt (implies (cst-matchp abnf::cst "type-parameter-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-parameter *( \",\" type-parameter )")))
Theorem:
(defthm cst-superclass-branches-match-alt (implies (cst-matchp abnf::cst "superclass") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"extends\" class-type")))
Theorem:
(defthm cst-superinterfaces-branches-match-alt (implies (cst-matchp abnf::cst "superinterfaces") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"implements\" interface-type-list")))
Theorem:
(defthm cst-interface-type-list-branches-match-alt (implies (cst-matchp abnf::cst "interface-type-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "interface-type *( \",\" interface-type )")))
Theorem:
(defthm cst-class-body-branches-match-alt (implies (cst-matchp abnf::cst "class-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" *class-body-declaration \"}\"")))
Theorem:
(defthm cst-class-body-declaration-branches-match-alt (implies (cst-matchp abnf::cst "class-body-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-member-declaration / instance-initializer / static-initializer / constructor-declaration")))
Theorem:
(defthm cst-class-member-declaration-branches-match-alt (implies (cst-matchp abnf::cst "class-member-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "field-declaration / method-declaration / class-declaration / interface-declaration / \";\"")))
Theorem:
(defthm cst-field-declaration-branches-match-alt (implies (cst-matchp abnf::cst "field-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*field-modifier unann-type variable-declarator-list \";\"")))
Theorem:
(defthm cst-variable-declarator-list-branches-match-alt (implies (cst-matchp abnf::cst "variable-declarator-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "variable-declarator *( \",\" variable-declarator )")))
Theorem:
(defthm cst-variable-declarator-branches-match-alt (implies (cst-matchp abnf::cst "variable-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "variable-declarator-id [ \"=\" variable-initializer ]")))
Theorem:
(defthm cst-variable-declarator-id-branches-match-alt (implies (cst-matchp abnf::cst "variable-declarator-id") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier [ dims ]")))
Theorem:
(defthm cst-variable-initializer-branches-match-alt (implies (cst-matchp abnf::cst "variable-initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression / array-initializer")))
Theorem:
(defthm cst-unann-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-primitive-type / unann-reference-type")))
Theorem:
(defthm cst-unann-primitive-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-primitive-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "numeric-type / %s\"boolean\"")))
Theorem:
(defthm cst-unann-reference-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-reference-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-or-interface-type / unann-type-variable / unann-array-type")))
Theorem:
(defthm cst-unann-class-or-interface-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-type / unann-interface-type")))
Theorem:
(defthm cst-unann-class-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-class-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")))
Theorem:
(defthm cst-unann-interface-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-interface-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-type")))
Theorem:
(defthm cst-unann-type-variable-branches-match-alt (implies (cst-matchp abnf::cst "unann-type-variable") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-identifier")))
Theorem:
(defthm cst-unann-array-type-branches-match-alt (implies (cst-matchp abnf::cst "unann-array-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-primitive-type dims / unann-class-or-interface-type dims / unann-type-variable dims")))
Theorem:
(defthm cst-field-modifier-branches-match-alt (implies (cst-matchp abnf::cst "field-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"static\" / %s\"final\" / %s\"transient\" / %s\"volatile\"")))
Theorem:
(defthm cst-method-declaration-branches-match-alt (implies (cst-matchp abnf::cst "method-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*method-modifier method-header method-body")))
Theorem:
(defthm cst-method-header-branches-match-alt (implies (cst-matchp abnf::cst "method-header") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "result method-declarator [ throws ] / type-parameters *annotation result method-declarator [ throws ]")))
Theorem:
(defthm cst-method-declarator-branches-match-alt (implies (cst-matchp abnf::cst "method-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]")))
Theorem:
(defthm cst-receiver-parameter-branches-match-alt (implies (cst-matchp abnf::cst "receiver-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation unann-type [ identifier \".\" ] %s\"this\"")))
Theorem:
(defthm cst-formal-parameter-list-branches-match-alt (implies (cst-matchp abnf::cst "formal-parameter-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "formal-parameter *( \",\" formal-parameter )")))
Theorem:
(defthm cst-formal-parameter-branches-match-alt (implies (cst-matchp abnf::cst "formal-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier unann-type variable-declarator-id / variable-arity-parameter")))
Theorem:
(defthm cst-variable-arity-parameter-branches-match-alt (implies (cst-matchp abnf::cst "variable-arity-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier unann-type *annotation \"...\" identifier")))
Theorem:
(defthm cst-variable-modifier-branches-match-alt (implies (cst-matchp abnf::cst "variable-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"final\"")))
Theorem:
(defthm cst-method-modifier-branches-match-alt (implies (cst-matchp abnf::cst "method-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"synchronized\" / %s\"native\" / %s\"strictfp\"")))
Theorem:
(defthm cst-result-branches-match-alt (implies (cst-matchp abnf::cst "result") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-type / %s\"void\"")))
Theorem:
(defthm cst-throws-branches-match-alt (implies (cst-matchp abnf::cst "throws") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"throws\" exception-type-list")))
Theorem:
(defthm cst-exception-type-list-branches-match-alt (implies (cst-matchp abnf::cst "exception-type-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "exception-type *( \",\" exception-type )")))
Theorem:
(defthm cst-exception-type-branches-match-alt (implies (cst-matchp abnf::cst "exception-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type / type-variable")))
Theorem:
(defthm cst-method-body-branches-match-alt (implies (cst-matchp abnf::cst "method-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "block / \";\"")))
Theorem:
(defthm cst-instance-initializer-branches-match-alt (implies (cst-matchp abnf::cst "instance-initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "block")))
Theorem:
(defthm cst-static-initializer-branches-match-alt (implies (cst-matchp abnf::cst "static-initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"static\" block")))
Theorem:
(defthm cst-constructor-declaration-branches-match-alt (implies (cst-matchp abnf::cst "constructor-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*constructor-modifier constructor-declarator [ throws ] constructor-body")))
Theorem:
(defthm cst-constructor-declarator-branches-match-alt (implies (cst-matchp abnf::cst "constructor-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\"")))
Theorem:
(defthm cst-simple-type-name-branches-match-alt (implies (cst-matchp abnf::cst "simple-type-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-identifier")))
Theorem:
(defthm cst-constructor-modifier-branches-match-alt (implies (cst-matchp abnf::cst "constructor-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"protected\" / %s\"private\"")))
Theorem:
(defthm cst-constructor-body-branches-match-alt (implies (cst-matchp abnf::cst "constructor-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ explicit-constructor-invocation ] [ block-statements ] \"}\"")))
Theorem:
(defthm cst-explicit-constructor-invocation-branches-match-alt (implies (cst-matchp abnf::cst "explicit-constructor-invocation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\" / [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"")))
Theorem:
(defthm cst-enum-declaration-branches-match-alt (implies (cst-matchp abnf::cst "enum-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*class-modifier %s\"enum\" type-identifier [ superinterfaces ] enum-body")))
Theorem:
(defthm cst-enum-body-branches-match-alt (implies (cst-matchp abnf::cst "enum-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\"")))
Theorem:
(defthm cst-enum-constant-list-branches-match-alt (implies (cst-matchp abnf::cst "enum-constant-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "enum-constant *( \",\" enum-constant )")))
Theorem:
(defthm cst-enum-constant-branches-match-alt (implies (cst-matchp abnf::cst "enum-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]")))
Theorem:
(defthm cst-enum-constant-modifier-branches-match-alt (implies (cst-matchp abnf::cst "enum-constant-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation")))
Theorem:
(defthm cst-enum-body-declarations-branches-match-alt (implies (cst-matchp abnf::cst "enum-body-declarations") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\";\" *class-body-declaration")))
Theorem:
(defthm cst-interface-declaration-branches-match-alt (implies (cst-matchp abnf::cst "interface-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-interface-declaration / annotation-type-declaration")))
Theorem:
(defthm cst-normal-interface-declaration-branches-match-alt (implies (cst-matchp abnf::cst "normal-interface-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ extends-interfaces ] interface-body")))
Theorem:
(defthm cst-interface-modifier-branches-match-alt (implies (cst-matchp abnf::cst "interface-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"strictfp\"")))
Theorem:
(defthm cst-extends-interfaces-branches-match-alt (implies (cst-matchp abnf::cst "extends-interfaces") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"extends\" interface-type-list")))
Theorem:
(defthm cst-interface-body-branches-match-alt (implies (cst-matchp abnf::cst "interface-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" *interface-member-declaration \"}\"")))
Theorem:
(defthm cst-interface-member-declaration-branches-match-alt (implies (cst-matchp abnf::cst "interface-member-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "constant-declaration / interface-method-declaration / class-declaration / interface-declaration / \";\"")))
Theorem:
(defthm cst-constant-declaration-branches-match-alt (implies (cst-matchp abnf::cst "constant-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*constant-modifier unann-type variable-declarator-list \";\"")))
Theorem:
(defthm cst-constant-modifier-branches-match-alt (implies (cst-matchp abnf::cst "constant-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"static\" / %s\"final\"")))
Theorem:
(defthm cst-interface-method-declaration-branches-match-alt (implies (cst-matchp abnf::cst "interface-method-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*interface-method-modifier method-header method-body")))
Theorem:
(defthm cst-interface-method-modifier-branches-match-alt (implies (cst-matchp abnf::cst "interface-method-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"private\" / %s\"abstract\" / %s\"default\" / %s\"static\" / %s\"strictfp\"")))
Theorem:
(defthm cst-annotation-type-declaration-branches-match-alt (implies (cst-matchp abnf::cst "annotation-type-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-type-body")))
Theorem:
(defthm cst-annotation-type-body-branches-match-alt (implies (cst-matchp abnf::cst "annotation-type-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" *annotation-type-member-declaration \"}\"")))
Theorem:
(defthm cst-annotation-type-member-declaration-branches-match-alt (implies (cst-matchp abnf::cst "annotation-type-member-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation-type-element-declaration / constant-declaration / class-declaration / interface-declaration / \";\"")))
Theorem:
(defthm cst-annotation-type-element-declaration-branches-match-alt (implies (cst-matchp abnf::cst "annotation-type-element-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation-type-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\"")))
Theorem:
(defthm cst-annotation-type-element-modifier-branches-match-alt (implies (cst-matchp abnf::cst "annotation-type-element-modifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation / %s\"public\" / %s\"abstract\"")))
Theorem:
(defthm cst-default-value-branches-match-alt (implies (cst-matchp abnf::cst "default-value") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"default\" element-value")))
Theorem:
(defthm cst-annotation-branches-match-alt (implies (cst-matchp abnf::cst "annotation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-annotation / marker-annotation / single-element-annotation")))
Theorem:
(defthm cst-normal-annotation-branches-match-alt (implies (cst-matchp abnf::cst "normal-annotation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"@\" type-name \"(\" [ element-value-pair-list ] \")\"")))
Theorem:
(defthm cst-element-value-pair-list-branches-match-alt (implies (cst-matchp abnf::cst "element-value-pair-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "element-value-pair *( \",\" element-value-pair )")))
Theorem:
(defthm cst-element-value-pair-branches-match-alt (implies (cst-matchp abnf::cst "element-value-pair") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier \"=\" element-value")))
Theorem:
(defthm cst-element-value-branches-match-alt (implies (cst-matchp abnf::cst "element-value") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression / element-value-array-initializer / annotation")))
Theorem:
(defthm cst-element-value-array-initializer-branches-match-alt (implies (cst-matchp abnf::cst "element-value-array-initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ element-value-list ] [ \",\" ] \"}\"")))
Theorem:
(defthm cst-element-value-list-branches-match-alt (implies (cst-matchp abnf::cst "element-value-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "element-value *( \",\" element-value )")))
Theorem:
(defthm cst-marker-annotation-branches-match-alt (implies (cst-matchp abnf::cst "marker-annotation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"@\" type-name")))
Theorem:
(defthm cst-single-element-annotation-branches-match-alt (implies (cst-matchp abnf::cst "single-element-annotation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"@\" type-name \"(\" element-value \")\"")))
Theorem:
(defthm cst-array-initializer-branches-match-alt (implies (cst-matchp abnf::cst "array-initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\"")))
Theorem:
(defthm cst-variable-initializer-list-branches-match-alt (implies (cst-matchp abnf::cst "variable-initializer-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "variable-initializer *( \",\" variable-initializer )")))
Theorem:
(defthm cst-block-branches-match-alt (implies (cst-matchp abnf::cst "block") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ block-statements ] \"}\"")))
Theorem:
(defthm cst-block-statements-branches-match-alt (implies (cst-matchp abnf::cst "block-statements") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*block-statement")))
Theorem:
(defthm cst-block-statement-branches-match-alt (implies (cst-matchp abnf::cst "block-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration-statement / class-declaration / statement")))
Theorem:
(defthm cst-local-variable-declaration-statement-branches-match-alt (implies (cst-matchp abnf::cst "local-variable-declaration-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration \";\"")))
Theorem:
(defthm cst-local-variable-declaration-branches-match-alt (implies (cst-matchp abnf::cst "local-variable-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier local-variable-type variable-declarator-list")))
Theorem:
(defthm cst-local-variable-type-branches-match-alt (implies (cst-matchp abnf::cst "local-variable-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-type / %s\"var\"")))
Theorem:
(defthm cst-statement-branches-match-alt (implies (cst-matchp abnf::cst "statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement / labeled-statement / if-then-statement / if-then-else-statement / while-statement / for-statement")))
Theorem:
(defthm cst-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement / labeled-statement-no-short-if / if-then-else-statement-no-short-if / while-statement-no-short-if / for-statement-no-short-if")))
Theorem:
(defthm cst-statement-without-trailing-substatement-branches-match-alt (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "block / empty-statement / expression-statement / assert-statement / switch-statement / do-statement / break-statement / continue-statement / return-statement / synchronized-statement / throw-statement / try-statement / yield-statement")))
Theorem:
(defthm cst-empty-statement-branches-match-alt (implies (cst-matchp abnf::cst "empty-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\";\"")))
Theorem:
(defthm cst-labeled-statement-branches-match-alt (implies (cst-matchp abnf::cst "labeled-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier \":\" statement")))
Theorem:
(defthm cst-labeled-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "labeled-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier \":\" statement-no-short-if")))
Theorem:
(defthm cst-expression-statement-branches-match-alt (implies (cst-matchp abnf::cst "expression-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression \";\"")))
Theorem:
(defthm cst-statement-expression-branches-match-alt (implies (cst-matchp abnf::cst "statement-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment / pre-increment-expression / pre-decrement-expression / post-increment-expression / post-decrement-expression / method-invocation / class-instance-creation-expression")))
Theorem:
(defthm cst-if-then-statement-branches-match-alt (implies (cst-matchp abnf::cst "if-then-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"if\" \"(\" expression \")\" statement")))
Theorem:
(defthm cst-if-then-else-statement-branches-match-alt (implies (cst-matchp abnf::cst "if-then-else-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement")))
Theorem:
(defthm cst-if-then-else-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "if-then-else-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if")))
Theorem:
(defthm cst-assert-statement-branches-match-alt (implies (cst-matchp abnf::cst "assert-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"assert\" expression \";\" / %s\"assert\" expression \":\" expression \";\"")))
Theorem:
(defthm cst-switch-statement-branches-match-alt (implies (cst-matchp abnf::cst "switch-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"switch\" \"(\" expression \")\" switch-block")))
Theorem:
(defthm cst-switch-block-branches-match-alt (implies (cst-matchp abnf::cst "switch-block") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" 1*switch-rule \"}\" / \"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\"")))
Theorem:
(defthm cst-switch-rule-branches-match-alt (implies (cst-matchp abnf::cst "switch-rule") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "switch-label \"->\" expression \";\" / switch-label \"->\" block / switch-label \"->\" throw-statement")))
Theorem:
(defthm cst-switch-block-statement-group-branches-match-alt (implies (cst-matchp abnf::cst "switch-block-statement-group") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "switch-label \":\" *( switch-label \":\" ) block-statements")))
Theorem:
(defthm cst-switch-label-branches-match-alt (implies (cst-matchp abnf::cst "switch-label") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"case\" case-constant *( \",\" case-constant ) / %s\"default\"")))
Theorem:
(defthm cst-case-constant-branches-match-alt (implies (cst-matchp abnf::cst "case-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression")))
Theorem:
(defthm cst-while-statement-branches-match-alt (implies (cst-matchp abnf::cst "while-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"while\" \"(\" expression \")\" statement")))
Theorem:
(defthm cst-while-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "while-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"while\" \"(\" expression \")\" statement-no-short-if")))
Theorem:
(defthm cst-do-statement-branches-match-alt (implies (cst-matchp abnf::cst "do-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"")))
Theorem:
(defthm cst-for-statement-branches-match-alt (implies (cst-matchp abnf::cst "for-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement / enhanced-for-statement")))
Theorem:
(defthm cst-for-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "for-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement-no-short-if / enhanced-for-statement-no-short-if")))
Theorem:
(defthm cst-basic-for-statement-branches-match-alt (implies (cst-matchp abnf::cst "basic-for-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement")))
Theorem:
(defthm cst-basic-for-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "basic-for-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if")))
Theorem:
(defthm cst-for-init-branches-match-alt (implies (cst-matchp abnf::cst "for-init") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression-list / local-variable-declaration")))
Theorem:
(defthm cst-for-update-branches-match-alt (implies (cst-matchp abnf::cst "for-update") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression-list")))
Theorem:
(defthm cst-statement-expression-list-branches-match-alt (implies (cst-matchp abnf::cst "statement-expression-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression *( \",\" statement-expression )")))
Theorem:
(defthm cst-enhanced-for-statement-branches-match-alt (implies (cst-matchp abnf::cst "enhanced-for-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement")))
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-branches-match-alt (implies (cst-matchp abnf::cst "enhanced-for-statement-no-short-if") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement-no-short-if")))
Theorem:
(defthm cst-break-statement-branches-match-alt (implies (cst-matchp abnf::cst "break-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"break\" [ identifier ] \";\"")))
Theorem:
(defthm cst-continue-statement-branches-match-alt (implies (cst-matchp abnf::cst "continue-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"continue\" [ identifier ] \";\"")))
Theorem:
(defthm cst-return-statement-branches-match-alt (implies (cst-matchp abnf::cst "return-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"return\" [ expression ] \";\"")))
Theorem:
(defthm cst-throw-statement-branches-match-alt (implies (cst-matchp abnf::cst "throw-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"throw\" expression \";\"")))
Theorem:
(defthm cst-synchronized-statement-branches-match-alt (implies (cst-matchp abnf::cst "synchronized-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"synchronized\" \"(\" expression \")\" block")))
Theorem:
(defthm cst-try-statement-branches-match-alt (implies (cst-matchp abnf::cst "try-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"try\" block catches / %s\"try\" block [ catches ] finally / try-with-resources-statement")))
Theorem:
(defthm cst-catches-branches-match-alt (implies (cst-matchp abnf::cst "catches") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*catch-clause")))
Theorem:
(defthm cst-catch-clause-branches-match-alt (implies (cst-matchp abnf::cst "catch-clause") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"catch\" \"(\" catch-formal-parameter \")\" block")))
Theorem:
(defthm cst-catch-formal-parameter-branches-match-alt (implies (cst-matchp abnf::cst "catch-formal-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier catch-type variable-declarator-id")))
Theorem:
(defthm cst-catch-type-branches-match-alt (implies (cst-matchp abnf::cst "catch-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-type *( \"|\" class-type )")))
Theorem:
(defthm cst-finally-branches-match-alt (implies (cst-matchp abnf::cst "finally") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"finally\" block")))
Theorem:
(defthm cst-try-with-resources-statement-branches-match-alt (implies (cst-matchp abnf::cst "try-with-resources-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"try\" resource-specification block [ catches ] [ finally ]")))
Theorem:
(defthm cst-resource-specification-branches-match-alt (implies (cst-matchp abnf::cst "resource-specification") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" resource-list [ \";\" ] \")\"")))
Theorem:
(defthm cst-resource-list-branches-match-alt (implies (cst-matchp abnf::cst "resource-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "resource *( \";\" resource )")))
Theorem:
(defthm cst-resource-branches-match-alt (implies (cst-matchp abnf::cst "resource") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier local-variable-type identifier \"=\" expression / variable-access")))
Theorem:
(defthm cst-variable-access-branches-match-alt (implies (cst-matchp abnf::cst "variable-access") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name / field-access")))
Theorem:
(defthm cst-yield-statement-branches-match-alt (implies (cst-matchp abnf::cst "yield-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"yield\" expression \";\"")))
Theorem:
(defthm cst-expression-branches-match-alt (implies (cst-matchp abnf::cst "expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "lambda-expression / assignment-expression")))
Theorem:
(defthm cst-primary-branches-match-alt (implies (cst-matchp abnf::cst "primary") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary-no-new-array / array-creation-expression")))
Theorem:
(defthm cst-primary-no-new-array-branches-match-alt (implies (cst-matchp abnf::cst "primary-no-new-array") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "literal / class-literal / %s\"this\" / type-name \".\" %s\"this\" / \"(\" expression \")\" / class-instance-creation-expression / field-access / array-access / method-invocation / method-reference")))
Theorem:
(defthm cst-class-literal-branches-match-alt (implies (cst-matchp abnf::cst "class-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-name *( \"[\" \"]\" ) \".\" %s\"class\" / numeric-type *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"void\" \".\" %s\"class\"")))
Theorem:
(defthm cst-class-instance-creation-expression-branches-match-alt (implies (cst-matchp abnf::cst "class-instance-creation-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unqualified-class-instance-creation-expression / expression-name \".\" unqualified-class-instance-creation-expression / primary \".\" unqualified-class-instance-creation-expression")))
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-branches-match-alt (implies (cst-matchp abnf::cst "unqualified-class-instance-creation-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]")))
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-branches-match-alt (implies (cst-matchp abnf::cst "class-or-interface-type-to-instantiate") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]")))
Theorem:
(defthm cst-type-arguments-or-diamond-branches-match-alt (implies (cst-matchp abnf::cst "type-arguments-or-diamond") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-arguments / \"<>\"")))
Theorem:
(defthm cst-array-creation-expression-branches-match-alt (implies (cst-matchp abnf::cst "array-creation-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"new\" primitive-type dim-exprs [ dims ] / %s\"new\" class-or-interface-type dim-exprs [ dims ] / %s\"new\" primitive-type dims array-initializer / %s\"new\" class-or-interface-type dims array-initializer")))
Theorem:
(defthm cst-dim-exprs-branches-match-alt (implies (cst-matchp abnf::cst "dim-exprs") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "1*dim-expr")))
Theorem:
(defthm cst-dim-expr-branches-match-alt (implies (cst-matchp abnf::cst "dim-expr") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*annotation \"[\" expression \"]\"")))
Theorem:
(defthm cst-array-access-branches-match-alt (implies (cst-matchp abnf::cst "array-access") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name \"[\" expression \"]\" / primary-no-new-array \"[\" expression \"]\"")))
Theorem:
(defthm cst-field-access-branches-match-alt (implies (cst-matchp abnf::cst "field-access") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary \".\" identifier / %s\"super\" \".\" identifier / type-name \".\" %s\"super\" \".\" identifier")))
Theorem:
(defthm cst-method-invocation-branches-match-alt (implies (cst-matchp abnf::cst "method-invocation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "method-name \"(\" [ argument-list ] \")\" / type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")))
Theorem:
(defthm cst-argument-list-branches-match-alt (implies (cst-matchp abnf::cst "argument-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression *( \",\" expression )")))
Theorem:
(defthm cst-method-reference-branches-match-alt (implies (cst-matchp abnf::cst "method-reference") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name \"::\" [ type-arguments ] identifier / primary \"::\" [ type-arguments ] identifier / reference-type \"::\" [ type-arguments ] identifier / %s\"super\" \"::\" [ type-arguments ] identifier / type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier / class-type \"::\" [ type-arguments ] %s\"new\" / array-type \"::\" %s\"new\"")))
Theorem:
(defthm cst-postfix-expression-branches-match-alt (implies (cst-matchp abnf::cst "postfix-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary / expression-name / post-increment-expression / post-decrement-expression")))
Theorem:
(defthm cst-post-increment-expression-branches-match-alt (implies (cst-matchp abnf::cst "post-increment-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "postfix-expression \"++\"")))
Theorem:
(defthm cst-post-decrement-expression-branches-match-alt (implies (cst-matchp abnf::cst "post-decrement-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "postfix-expression \"--\"")))
Theorem:
(defthm cst-unary-expression-branches-match-alt (implies (cst-matchp abnf::cst "unary-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "pre-increment-expression / pre-decrement-expression / \"+\" unary-expression / \"-\" unary-expression / unary-expression-not-plus-minus")))
Theorem:
(defthm cst-pre-increment-expression-branches-match-alt (implies (cst-matchp abnf::cst "pre-increment-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"++\" unary-expression")))
Theorem:
(defthm cst-pre-decrement-expression-branches-match-alt (implies (cst-matchp abnf::cst "pre-decrement-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"--\" unary-expression")))
Theorem:
(defthm cst-unary-expression-not-plus-minus-branches-match-alt (implies (cst-matchp abnf::cst "unary-expression-not-plus-minus") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "postfix-expression / \"~\" unary-expression / \"!\" unary-expression / cast-expression / switch-expression")))
Theorem:
(defthm cst-cast-expression-branches-match-alt (implies (cst-matchp abnf::cst "cast-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" primitive-type \")\" unary-expression / \"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus / \"(\" reference-type *additional-bound \")\" lambda-expression")))
Theorem:
(defthm cst-multiplicative-expression-branches-match-alt (implies (cst-matchp abnf::cst "multiplicative-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unary-expression / multiplicative-expression \"*\" unary-expression / multiplicative-expression \"/\" unary-expression / multiplicative-expression \"%\" unary-expression")))
Theorem:
(defthm cst-additive-expression-branches-match-alt (implies (cst-matchp abnf::cst "additive-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "multiplicative-expression / additive-expression \"+\" multiplicative-expression / additive-expression \"-\" multiplicative-expression")))
Theorem:
(defthm cst-shift-expression-branches-match-alt (implies (cst-matchp abnf::cst "shift-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "additive-expression / shift-expression \"<<\" additive-expression / shift-expression \">>\" additive-expression / shift-expression \">>>\" additive-expression")))
Theorem:
(defthm cst-relational-expression-branches-match-alt (implies (cst-matchp abnf::cst "relational-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "shift-expression / relational-expression \"<\" shift-expression / relational-expression \">\" shift-expression / relational-expression \"<=\" shift-expression / relational-expression \">=\" shift-expression / relational-expression %s\"instanceof\" reference-type")))
Theorem:
(defthm cst-equality-expression-branches-match-alt (implies (cst-matchp abnf::cst "equality-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "relational-expression / equality-expression \"==\" relational-expression / equality-expression \"!=\" relational-expression")))
Theorem:
(defthm cst-and-expression-branches-match-alt (implies (cst-matchp abnf::cst "and-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "equality-expression / and-expression \"&\" equality-expression")))
Theorem:
(defthm cst-exclusive-or-expression-branches-match-alt (implies (cst-matchp abnf::cst "exclusive-or-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "and-expression / exclusive-or-expression \"^\" and-expression")))
Theorem:
(defthm cst-inclusive-or-expression-branches-match-alt (implies (cst-matchp abnf::cst "inclusive-or-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "exclusive-or-expression / inclusive-or-expression \"|\" exclusive-or-expression")))
Theorem:
(defthm cst-conditional-and-expression-branches-match-alt (implies (cst-matchp abnf::cst "conditional-and-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "inclusive-or-expression / conditional-and-expression \"&&\" inclusive-or-expression")))
Theorem:
(defthm cst-conditional-or-expression-branches-match-alt (implies (cst-matchp abnf::cst "conditional-or-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-and-expression / conditional-or-expression \"||\" conditional-and-expression")))
Theorem:
(defthm cst-conditional-expression-branches-match-alt (implies (cst-matchp abnf::cst "conditional-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-or-expression / conditional-or-expression \"?\" expression \":\" conditional-expression / conditional-or-expression \"?\" expression \":\" lambda-expression")))
Theorem:
(defthm cst-assignment-expression-branches-match-alt (implies (cst-matchp abnf::cst "assignment-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression / assignment")))
Theorem:
(defthm cst-assignment-branches-match-alt (implies (cst-matchp abnf::cst "assignment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "left-hand-side assignment-operator expression")))
Theorem:
(defthm cst-left-hand-side-branches-match-alt (implies (cst-matchp abnf::cst "left-hand-side") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name / field-access / array-access")))
Theorem:
(defthm cst-assignment-operator-branches-match-alt (implies (cst-matchp abnf::cst "assignment-operator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"=\" / \"*=\" / \"/=\" / \"%=\" / \"+=\" / \"-=\" / \"<<=\" / \">>=\" / \">>>=\" / \"&=\" / \"^=\" / \"|=\"")))
Theorem:
(defthm cst-lambda-expression-branches-match-alt (implies (cst-matchp abnf::cst "lambda-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "lambda-parameters \"->\" lambda-body")))
Theorem:
(defthm cst-lambda-parameters-branches-match-alt (implies (cst-matchp abnf::cst "lambda-parameters") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" [ lambda-parameter-list ] \")\" / identifier")))
Theorem:
(defthm cst-lambda-parameter-list-branches-match-alt (implies (cst-matchp abnf::cst "lambda-parameter-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "lambda-parameter *( \",\" lambda-parameter ) / identifier *( \",\" identifier )")))
Theorem:
(defthm cst-lambda-parameter-branches-match-alt (implies (cst-matchp abnf::cst "lambda-parameter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "*variable-modifier lambda-parameter-type variable-declarator-id / variable-arity-parameter")))
Theorem:
(defthm cst-lambda-parameter-type-branches-match-alt (implies (cst-matchp abnf::cst "lambda-parameter-type") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-type / %s\"var\"")))
Theorem:
(defthm cst-lambda-body-branches-match-alt (implies (cst-matchp abnf::cst "lambda-body") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression / block")))
Theorem:
(defthm cst-switch-expression-branches-match-alt (implies (cst-matchp abnf::cst "switch-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"switch\" \"(\" expression \")\" switch-block")))
Theorem:
(defthm cst-constant-expression-branches-match-alt (implies (cst-matchp abnf::cst "constant-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression")))
Theorem:
(defthm cst-unicode-input-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "unicode-escape / raw-input-character") (or (cst-list-list-conc-matchp abnf::cstss "unicode-escape") (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))
Theorem:
(defthm cst-unicode-escape-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit") (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit"))))
Theorem:
(defthm cst-unicode-marker-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*%s\"u\"") (or (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\""))))
Theorem:
(defthm cst-hex-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "\"1\"") (cst-list-list-conc-matchp abnf::cstss "\"2\"") (cst-list-list-conc-matchp abnf::cstss "\"3\"") (cst-list-list-conc-matchp abnf::cstss "\"4\"") (cst-list-list-conc-matchp abnf::cstss "\"5\"") (cst-list-list-conc-matchp abnf::cstss "\"6\"") (cst-list-list-conc-matchp abnf::cstss "\"7\"") (cst-list-list-conc-matchp abnf::cstss "\"8\"") (cst-list-list-conc-matchp abnf::cstss "\"9\"") (cst-list-list-conc-matchp abnf::cstss "\"a\"") (cst-list-list-conc-matchp abnf::cstss "\"b\"") (cst-list-list-conc-matchp abnf::cstss "\"c\"") (cst-list-list-conc-matchp abnf::cstss "\"d\"") (cst-list-list-conc-matchp abnf::cstss "\"e\"") (cst-list-list-conc-matchp abnf::cstss "\"f\""))))
Theorem:
(defthm cst-raw-input-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x0-FFFF") (or (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF"))))
Theorem:
(defthm cst-line-terminator-concs (implies (cst-list-list-alt-matchp abnf::cstss "%d10 / %d13 / %d13.10") (or (cst-list-list-conc-matchp abnf::cstss "%d10") (cst-list-list-conc-matchp abnf::cstss "%d13") (cst-list-list-conc-matchp abnf::cstss "%d13.10"))))
Theorem:
(defthm cst-input-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "unicode-input-character") (or (cst-list-list-conc-matchp abnf::cstss "unicode-input-character"))))
Theorem:
(defthm cst-input-concs (implies (cst-list-list-alt-matchp abnf::cstss "*input-element [ sub ]") (or (cst-list-list-conc-matchp abnf::cstss "*input-element [ sub ]"))))
Theorem:
(defthm cst-input-element-concs (implies (cst-list-list-alt-matchp abnf::cstss "white-space / comment / token") (or (cst-list-list-conc-matchp abnf::cstss "white-space") (cst-list-list-conc-matchp abnf::cstss "comment") (cst-list-list-conc-matchp abnf::cstss "token"))))
Theorem:
(defthm cst-token-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / keyword / literal / separator / operator") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "keyword") (cst-list-list-conc-matchp abnf::cstss "literal") (cst-list-list-conc-matchp abnf::cstss "separator") (cst-list-list-conc-matchp abnf::cstss "operator"))))
Theorem:
(defthm cst-sub-concs (implies (cst-list-list-alt-matchp abnf::cstss "%d26") (or (cst-list-list-conc-matchp abnf::cstss "%d26"))))
Theorem:
(defthm cst-white-space-concs (implies (cst-list-list-alt-matchp abnf::cstss "%d32 / %d9 / %d12 / line-terminator") (or (cst-list-list-conc-matchp abnf::cstss "%d32") (cst-list-list-conc-matchp abnf::cstss "%d9") (cst-list-list-conc-matchp abnf::cstss "%d12") (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))
Theorem:
(defthm cst-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "traditional-comment / end-of-line-comment") (or (cst-list-list-conc-matchp abnf::cstss "traditional-comment") (cst-list-list-conc-matchp abnf::cstss "end-of-line-comment"))))
Theorem:
(defthm cst-traditional-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"/\" \"*\" comment-tail") (or (cst-list-list-conc-matchp abnf::cstss "\"/\" \"*\" comment-tail"))))
Theorem:
(defthm cst-comment-tail-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"*\" comment-tail-star / not-star comment-tail") (or (cst-list-list-conc-matchp abnf::cstss "\"*\" comment-tail-star") (cst-list-list-conc-matchp abnf::cstss "not-star comment-tail"))))
Theorem:
(defthm cst-comment-tail-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"/\" / \"*\" comment-tail-star / not-star-not-slash comment-tail") (or (cst-list-list-conc-matchp abnf::cstss "\"/\"") (cst-list-list-conc-matchp abnf::cstss "\"*\" comment-tail-star") (cst-list-list-conc-matchp abnf::cstss "not-star-not-slash comment-tail"))))
Theorem:
(defthm cst-not-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "input-character / line-terminator") (or (cst-list-list-conc-matchp abnf::cstss "input-character") (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))
Theorem:
(defthm cst-not-star-not-slash-concs (implies (cst-list-list-alt-matchp abnf::cstss "input-character / line-terminator") (or (cst-list-list-conc-matchp abnf::cstss "input-character") (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))
Theorem:
(defthm cst-end-of-line-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"/\" \"/\" *input-character") (or (cst-list-list-conc-matchp abnf::cstss "\"/\" \"/\" *input-character"))))
Theorem:
(defthm cst-identifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier-chars") (or (cst-list-list-conc-matchp abnf::cstss "identifier-chars"))))
Theorem:
(defthm cst-identifier-chars-concs (implies (cst-list-list-alt-matchp abnf::cstss "java-letter *java-letter-or-digit") (or (cst-list-list-conc-matchp abnf::cstss "java-letter *java-letter-or-digit"))))
Theorem:
(defthm cst-java-letter-concs (implies (cst-list-list-alt-matchp abnf::cstss "raw-input-character") (or (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))
Theorem:
(defthm cst-java-letter-or-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "raw-input-character") (or (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))
Theorem:
(defthm cst-type-identifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))
Theorem:
(defthm cst-unqualified-method-identifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))
Theorem:
(defthm cst-keyword-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"abstract\" / %s\"assert\" / %s\"boolean\" / %s\"break\" / %s\"byte\" / %s\"case\" / %s\"catch\" / %s\"char\" / %s\"class\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extends\" / %s\"final\" / %s\"finally\" / %s\"float\" / %s\"for\" / %s\"if\" / %s\"goto\" / %s\"implements\" / %s\"import\" / %s\"instanceof\" / %s\"int\" / %s\"interface\" / %s\"long\" / %s\"native\" / %s\"new\" / %s\"package\" / %s\"private\" / %s\"protected\" / %s\"public\" / %s\"return\" / %s\"short\" / %s\"static\" / %s\"strictfp\" / %s\"super\" / %s\"switch\" / %s\"synchronized\" / %s\"this\" / %s\"throw\" / %s\"throws\" / %s\"transient\" / %s\"try\" / %s\"void\" / %s\"volatile\" / %s\"while\" / \"_\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (cst-list-list-conc-matchp abnf::cstss "%s\"assert\"") (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"") (cst-list-list-conc-matchp abnf::cstss "%s\"break\"") (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"") (cst-list-list-conc-matchp abnf::cstss "%s\"case\"") (cst-list-list-conc-matchp abnf::cstss "%s\"catch\"") (cst-list-list-conc-matchp abnf::cstss "%s\"char\"") (cst-list-list-conc-matchp abnf::cstss "%s\"class\"") (cst-list-list-conc-matchp abnf::cstss "%s\"const\"") (cst-list-list-conc-matchp abnf::cstss "%s\"continue\"") (cst-list-list-conc-matchp abnf::cstss "%s\"default\"") (cst-list-list-conc-matchp abnf::cstss "%s\"do\"") (cst-list-list-conc-matchp abnf::cstss "%s\"double\"") (cst-list-list-conc-matchp abnf::cstss "%s\"else\"") (cst-list-list-conc-matchp abnf::cstss "%s\"enum\"") (cst-list-list-conc-matchp abnf::cstss "%s\"extends\"") (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (cst-list-list-conc-matchp abnf::cstss "%s\"finally\"") (cst-list-list-conc-matchp abnf::cstss "%s\"float\"") (cst-list-list-conc-matchp abnf::cstss "%s\"for\"") (cst-list-list-conc-matchp abnf::cstss "%s\"if\"") (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"") (cst-list-list-conc-matchp abnf::cstss "%s\"implements\"") (cst-list-list-conc-matchp abnf::cstss "%s\"import\"") (cst-list-list-conc-matchp abnf::cstss "%s\"instanceof\"") (cst-list-list-conc-matchp abnf::cstss "%s\"int\"") (cst-list-list-conc-matchp abnf::cstss "%s\"interface\"") (cst-list-list-conc-matchp abnf::cstss "%s\"long\"") (cst-list-list-conc-matchp abnf::cstss "%s\"native\"") (cst-list-list-conc-matchp abnf::cstss "%s\"new\"") (cst-list-list-conc-matchp abnf::cstss "%s\"package\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"return\"") (cst-list-list-conc-matchp abnf::cstss "%s\"short\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (cst-list-list-conc-matchp abnf::cstss "%s\"super\"") (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"") (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"") (cst-list-list-conc-matchp abnf::cstss "%s\"this\"") (cst-list-list-conc-matchp abnf::cstss "%s\"throw\"") (cst-list-list-conc-matchp abnf::cstss "%s\"throws\"") (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"") (cst-list-list-conc-matchp abnf::cstss "%s\"try\"") (cst-list-list-conc-matchp abnf::cstss "%s\"void\"") (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"") (cst-list-list-conc-matchp abnf::cstss "%s\"while\"") (cst-list-list-conc-matchp abnf::cstss "\"_\""))))
Theorem:
(defthm cst-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "integer-literal / floating-point-literal / boolean-literal / character-literal / string-literal / null-literal") (or (cst-list-list-conc-matchp abnf::cstss "integer-literal") (cst-list-list-conc-matchp abnf::cstss "floating-point-literal") (cst-list-list-conc-matchp abnf::cstss "boolean-literal") (cst-list-list-conc-matchp abnf::cstss "character-literal") (cst-list-list-conc-matchp abnf::cstss "string-literal") (cst-list-list-conc-matchp abnf::cstss "null-literal"))))
Theorem:
(defthm cst-integer-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "decimal-integer-literal / hex-integer-literal / octal-integer-literal / binary-integer-literal") (or (cst-list-list-conc-matchp abnf::cstss "decimal-integer-literal") (cst-list-list-conc-matchp abnf::cstss "hex-integer-literal") (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal") (cst-list-list-conc-matchp abnf::cstss "binary-integer-literal"))))
Theorem:
(defthm cst-decimal-integer-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "decimal-numeral [ integer-type-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "decimal-numeral [ integer-type-suffix ]"))))
Theorem:
(defthm cst-hex-integer-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "hex-numeral [ integer-type-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "hex-numeral [ integer-type-suffix ]"))))
Theorem:
(defthm cst-octal-integer-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "octal-numeral [ integer-type-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "octal-numeral [ integer-type-suffix ]"))))
Theorem:
(defthm cst-binary-integer-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "binary-numeral [ integer-type-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "binary-numeral [ integer-type-suffix ]"))))
Theorem:
(defthm cst-integer-type-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"l\"") (or (cst-list-list-conc-matchp abnf::cstss "\"l\""))))
Theorem:
(defthm cst-decimal-numeral-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / non-zero-digit [ digits ] / non-zero-digit underscores digits") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "non-zero-digit [ digits ]") (cst-list-list-conc-matchp abnf::cstss "non-zero-digit underscores digits"))))
Theorem:
(defthm cst-non-zero-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"") (or (cst-list-list-conc-matchp abnf::cstss "\"1\"") (cst-list-list-conc-matchp abnf::cstss "\"2\"") (cst-list-list-conc-matchp abnf::cstss "\"3\"") (cst-list-list-conc-matchp abnf::cstss "\"4\"") (cst-list-list-conc-matchp abnf::cstss "\"5\"") (cst-list-list-conc-matchp abnf::cstss "\"6\"") (cst-list-list-conc-matchp abnf::cstss "\"7\"") (cst-list-list-conc-matchp abnf::cstss "\"8\"") (cst-list-list-conc-matchp abnf::cstss "\"9\""))))
Theorem:
(defthm cst-digits-concs (implies (cst-list-list-alt-matchp abnf::cstss "digit / digit [ digits-and-underscores ] digit") (or (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "digit [ digits-and-underscores ] digit"))))
Theorem:
(defthm cst-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / non-zero-digit") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "non-zero-digit"))))
Theorem:
(defthm cst-digits-and-underscores-concs (implies (cst-list-list-alt-matchp abnf::cstss "digit-or-underscore *digit-or-underscore") (or (cst-list-list-conc-matchp abnf::cstss "digit-or-underscore *digit-or-underscore"))))
Theorem:
(defthm cst-digit-or-underscore-concs (implies (cst-list-list-alt-matchp abnf::cstss "digit / \"_\"") (or (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "\"_\""))))
Theorem:
(defthm cst-underscores-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*\"_\"") (or (cst-list-list-conc-matchp abnf::cstss "1*\"_\""))))
Theorem:
(defthm cst-hex-numeral-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0x\" hex-digits") (or (cst-list-list-conc-matchp abnf::cstss "\"0x\" hex-digits"))))
Theorem:
(defthm cst-hex-digits-concs (implies (cst-list-list-alt-matchp abnf::cstss "hex-digit / hex-digit [ hex-digits-and-underscores ] hex-digit") (or (cst-list-list-conc-matchp abnf::cstss "hex-digit") (cst-list-list-conc-matchp abnf::cstss "hex-digit [ hex-digits-and-underscores ] hex-digit"))))
Theorem:
(defthm cst-hex-digits-and-underscores-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*hex-digit-or-underscore") (or (cst-list-list-conc-matchp abnf::cstss "1*hex-digit-or-underscore"))))
Theorem:
(defthm cst-hex-digit-or-underscore-concs (implies (cst-list-list-alt-matchp abnf::cstss "hex-digit / \"_\"") (or (cst-list-list-conc-matchp abnf::cstss "hex-digit") (cst-list-list-conc-matchp abnf::cstss "\"_\""))))
Theorem:
(defthm cst-octal-numeral-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" octal-digits / \"0\" underscores octal-digits") (or (cst-list-list-conc-matchp abnf::cstss "\"0\" octal-digits") (cst-list-list-conc-matchp abnf::cstss "\"0\" underscores octal-digits"))))
Theorem:
(defthm cst-octal-digits-concs (implies (cst-list-list-alt-matchp abnf::cstss "octal-digit / octal-digit [ octal-digits-and-underscores ] octal-digit") (or (cst-list-list-conc-matchp abnf::cstss "octal-digit") (cst-list-list-conc-matchp abnf::cstss "octal-digit [ octal-digits-and-underscores ] octal-digit"))))
Theorem:
(defthm cst-octal-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\"") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "\"1\"") (cst-list-list-conc-matchp abnf::cstss "\"2\"") (cst-list-list-conc-matchp abnf::cstss "\"3\"") (cst-list-list-conc-matchp abnf::cstss "\"4\"") (cst-list-list-conc-matchp abnf::cstss "\"5\"") (cst-list-list-conc-matchp abnf::cstss "\"6\"") (cst-list-list-conc-matchp abnf::cstss "\"7\""))))
Theorem:
(defthm cst-octal-digits-and-underscores-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*octal-digit-or-underscore") (or (cst-list-list-conc-matchp abnf::cstss "1*octal-digit-or-underscore"))))
Theorem:
(defthm cst-octal-digit-or-underscore-concs (implies (cst-list-list-alt-matchp abnf::cstss "octal-digit / \"_\"") (or (cst-list-list-conc-matchp abnf::cstss "octal-digit") (cst-list-list-conc-matchp abnf::cstss "\"_\""))))
Theorem:
(defthm cst-binary-numeral-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0b\" binary-digits") (or (cst-list-list-conc-matchp abnf::cstss "\"0b\" binary-digits"))))
Theorem:
(defthm cst-binary-digits-concs (implies (cst-list-list-alt-matchp abnf::cstss "binary-digit / binary-digit [ binary-digits-and-underscores ] binary-digit") (or (cst-list-list-conc-matchp abnf::cstss "binary-digit") (cst-list-list-conc-matchp abnf::cstss "binary-digit [ binary-digits-and-underscores ] binary-digit"))))
Theorem:
(defthm cst-binary-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\"") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "\"1\""))))
Theorem:
(defthm cst-binary-digits-and-underscores-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*binary-digit-or-underscore") (or (cst-list-list-conc-matchp abnf::cstss "1*binary-digit-or-underscore"))))
Theorem:
(defthm cst-binary-digit-or-underscore-concs (implies (cst-list-list-alt-matchp abnf::cstss "binary-digit / \"_\"") (or (cst-list-list-conc-matchp abnf::cstss "binary-digit") (cst-list-list-conc-matchp abnf::cstss "\"_\""))))
Theorem:
(defthm cst-floating-point-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "decimal-floating-point-literal / hexadecimal-floating-point-literal") (or (cst-list-list-conc-matchp abnf::cstss "decimal-floating-point-literal") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-point-literal"))))
Theorem:
(defthm cst-decimal-floating-point-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ] / \".\" digits [ exponent-part ] [ float-type-suffix ] / digits exponent-part [ float-type-suffix ] / digits [ exponent-part ] float-type-suffix") (or (cst-list-list-conc-matchp abnf::cstss "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ]") (cst-list-list-conc-matchp abnf::cstss "\".\" digits [ exponent-part ] [ float-type-suffix ]") (cst-list-list-conc-matchp abnf::cstss "digits exponent-part [ float-type-suffix ]") (cst-list-list-conc-matchp abnf::cstss "digits [ exponent-part ] float-type-suffix"))))
Theorem:
(defthm cst-exponent-part-concs (implies (cst-list-list-alt-matchp abnf::cstss "exponent-indicator signed-integer") (or (cst-list-list-conc-matchp abnf::cstss "exponent-indicator signed-integer"))))
Theorem:
(defthm cst-exponent-indicator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"e\"") (or (cst-list-list-conc-matchp abnf::cstss "\"e\""))))
Theorem:
(defthm cst-signed-integer-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ sign ] digits") (or (cst-list-list-conc-matchp abnf::cstss "[ sign ] digits"))))
Theorem:
(defthm cst-sign-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"+\" / \"-\"") (or (cst-list-list-conc-matchp abnf::cstss "\"+\"") (cst-list-list-conc-matchp abnf::cstss "\"-\""))))
Theorem:
(defthm cst-float-type-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"f\" / \"d\"") (or (cst-list-list-conc-matchp abnf::cstss "\"f\"") (cst-list-list-conc-matchp abnf::cstss "\"d\""))))
Theorem:
(defthm cst-hexadecimal-floating-point-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "hex-significand binary-exponent [ float-type-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "hex-significand binary-exponent [ float-type-suffix ]"))))
Theorem:
(defthm cst-hex-significand-concs (implies (cst-list-list-alt-matchp abnf::cstss "hex-numeral [ \".\" ] / \"0x\" [ hex-digits ] \".\" hex-digits") (or (cst-list-list-conc-matchp abnf::cstss "hex-numeral [ \".\" ]") (cst-list-list-conc-matchp abnf::cstss "\"0x\" [ hex-digits ] \".\" hex-digits"))))
Theorem:
(defthm cst-binary-exponent-concs (implies (cst-list-list-alt-matchp abnf::cstss "binary-exponent-indicator signed-integer") (or (cst-list-list-conc-matchp abnf::cstss "binary-exponent-indicator signed-integer"))))
Theorem:
(defthm cst-binary-exponent-indicator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"p\"") (or (cst-list-list-conc-matchp abnf::cstss "\"p\""))))
Theorem:
(defthm cst-boolean-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"true\" / %s\"false\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"true\"") (cst-list-list-conc-matchp abnf::cstss "%s\"false\""))))
Theorem:
(defthm cst-character-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"'\" single-character \"'\" / \"'\" escape-sequence \"'\"") (or (cst-list-list-conc-matchp abnf::cstss "\"'\" single-character \"'\"") (cst-list-list-conc-matchp abnf::cstss "\"'\" escape-sequence \"'\""))))
Theorem:
(defthm cst-single-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "input-character") (or (cst-list-list-conc-matchp abnf::cstss "input-character"))))
Theorem:
(defthm cst-string-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "%d34 *string-character %d34") (or (cst-list-list-conc-matchp abnf::cstss "%d34 *string-character %d34"))))
Theorem:
(defthm cst-string-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "input-character / escape-sequence") (or (cst-list-list-conc-matchp abnf::cstss "input-character") (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\b\" / %s\"\\t\" / %s\"\\n\" / %s\"\\f\" / %s\"\\r\" / \"\\\" %d34 / \"\\'\" / \"\\\\\" / octal-escape") (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"") (cst-list-list-conc-matchp abnf::cstss "\"\\\" %d34") (cst-list-list-conc-matchp abnf::cstss "\"\\'\"") (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"") (cst-list-list-conc-matchp abnf::cstss "octal-escape"))))
Theorem:
(defthm cst-octal-escape-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" zero-to-three octal-digit octal-digit") (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit") (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit octal-digit") (cst-list-list-conc-matchp abnf::cstss "\"\\\" zero-to-three octal-digit octal-digit"))))
Theorem:
(defthm cst-zero-to-three-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\"") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "\"1\"") (cst-list-list-conc-matchp abnf::cstss "\"2\""))))
Theorem:
(defthm cst-null-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"null\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"null\""))))
Theorem:
(defthm cst-separator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" / \")\" / \"{\" / \"}\" / \"[\" / \"]\" / \";\" / \",\" / \".\" / \"...\" / \"@\" / \"::\"") (or (cst-list-list-conc-matchp abnf::cstss "\"(\"") (cst-list-list-conc-matchp abnf::cstss "\")\"") (cst-list-list-conc-matchp abnf::cstss "\"{\"") (cst-list-list-conc-matchp abnf::cstss "\"}\"") (cst-list-list-conc-matchp abnf::cstss "\"[\"") (cst-list-list-conc-matchp abnf::cstss "\"]\"") (cst-list-list-conc-matchp abnf::cstss "\";\"") (cst-list-list-conc-matchp abnf::cstss "\",\"") (cst-list-list-conc-matchp abnf::cstss "\".\"") (cst-list-list-conc-matchp abnf::cstss "\"...\"") (cst-list-list-conc-matchp abnf::cstss "\"@\"") (cst-list-list-conc-matchp abnf::cstss "\"::\""))))
Theorem:
(defthm cst-operator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"=\" / \">\" / \"<\" / \"!\" / \"~\" / \"?\" / \":\" / \"->\" / \"==\" / \">=\" / \"<=\" / \"!=\" / \"&&\" / \"||\" / \"++\" / \"--\" / \"+\" / \"-\" / \"*\" / \"/\" / \"&\" / \"|\" / \"^\" / \"%\" / \"<<\" / \">>\" / \">>>\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"&=\" / \"|=\" / \"^=\" / \"%=\" / \"<<=\" / \">>=\" / \">>>=\"") (or (cst-list-list-conc-matchp abnf::cstss "\"=\"") (cst-list-list-conc-matchp abnf::cstss "\">\"") (cst-list-list-conc-matchp abnf::cstss "\"<\"") (cst-list-list-conc-matchp abnf::cstss "\"!\"") (cst-list-list-conc-matchp abnf::cstss "\"~\"") (cst-list-list-conc-matchp abnf::cstss "\"?\"") (cst-list-list-conc-matchp abnf::cstss "\":\"") (cst-list-list-conc-matchp abnf::cstss "\"->\"") (cst-list-list-conc-matchp abnf::cstss "\"==\"") (cst-list-list-conc-matchp abnf::cstss "\">=\"") (cst-list-list-conc-matchp abnf::cstss "\"<=\"") (cst-list-list-conc-matchp abnf::cstss "\"!=\"") (cst-list-list-conc-matchp abnf::cstss "\"&&\"") (cst-list-list-conc-matchp abnf::cstss "\"||\"") (cst-list-list-conc-matchp abnf::cstss "\"++\"") (cst-list-list-conc-matchp abnf::cstss "\"--\"") (cst-list-list-conc-matchp abnf::cstss "\"+\"") (cst-list-list-conc-matchp abnf::cstss "\"-\"") (cst-list-list-conc-matchp abnf::cstss "\"*\"") (cst-list-list-conc-matchp abnf::cstss "\"/\"") (cst-list-list-conc-matchp abnf::cstss "\"&\"") (cst-list-list-conc-matchp abnf::cstss "\"|\"") (cst-list-list-conc-matchp abnf::cstss "\"^\"") (cst-list-list-conc-matchp abnf::cstss "\"%\"") (cst-list-list-conc-matchp abnf::cstss "\"<<\"") (cst-list-list-conc-matchp abnf::cstss "\">>\"") (cst-list-list-conc-matchp abnf::cstss "\">>>\"") (cst-list-list-conc-matchp abnf::cstss "\"+=\"") (cst-list-list-conc-matchp abnf::cstss "\"-=\"") (cst-list-list-conc-matchp abnf::cstss "\"*=\"") (cst-list-list-conc-matchp abnf::cstss "\"/=\"") (cst-list-list-conc-matchp abnf::cstss "\"&=\"") (cst-list-list-conc-matchp abnf::cstss "\"|=\"") (cst-list-list-conc-matchp abnf::cstss "\"^=\"") (cst-list-list-conc-matchp abnf::cstss "\"%=\"") (cst-list-list-conc-matchp abnf::cstss "\"<<=\"") (cst-list-list-conc-matchp abnf::cstss "\">>=\"") (cst-list-list-conc-matchp abnf::cstss "\">>>=\""))))
Theorem:
(defthm cst-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "primitive-type / reference-type") (or (cst-list-list-conc-matchp abnf::cstss "primitive-type") (cst-list-list-conc-matchp abnf::cstss "reference-type"))))
Theorem:
(defthm cst-primitive-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation numeric-type / *annotation %s\"boolean\"") (or (cst-list-list-conc-matchp abnf::cstss "*annotation numeric-type") (cst-list-list-conc-matchp abnf::cstss "*annotation %s\"boolean\""))))
Theorem:
(defthm cst-numeric-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "integral-type / floating-point-type") (or (cst-list-list-conc-matchp abnf::cstss "integral-type") (cst-list-list-conc-matchp abnf::cstss "floating-point-type"))))
Theorem:
(defthm cst-integral-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"byte\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"char\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"") (cst-list-list-conc-matchp abnf::cstss "%s\"short\"") (cst-list-list-conc-matchp abnf::cstss "%s\"int\"") (cst-list-list-conc-matchp abnf::cstss "%s\"long\"") (cst-list-list-conc-matchp abnf::cstss "%s\"char\""))))
Theorem:
(defthm cst-floating-point-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"float\" / %s\"double\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"float\"") (cst-list-list-conc-matchp abnf::cstss "%s\"double\""))))
Theorem:
(defthm cst-reference-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-or-interface-type / type-variable / array-type") (or (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type") (cst-list-list-conc-matchp abnf::cstss "type-variable") (cst-list-list-conc-matchp abnf::cstss "array-type"))))
Theorem:
(defthm cst-class-or-interface-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-type / interface-type") (or (cst-list-list-conc-matchp abnf::cstss "class-type") (cst-list-list-conc-matchp abnf::cstss "interface-type"))))
Theorem:
(defthm cst-class-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]") (or (cst-list-list-conc-matchp abnf::cstss "*annotation type-identifier [ type-arguments ]") (cst-list-list-conc-matchp abnf::cstss "package-name \".\" *annotation type-identifier [ type-arguments ]") (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]"))))
Theorem:
(defthm cst-interface-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-type") (or (cst-list-list-conc-matchp abnf::cstss "class-type"))))
Theorem:
(defthm cst-type-variable-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation type-identifier") (or (cst-list-list-conc-matchp abnf::cstss "*annotation type-identifier"))))
Theorem:
(defthm cst-array-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "primitive-type dims / class-or-interface-type dims / type-variable dims") (or (cst-list-list-conc-matchp abnf::cstss "primitive-type dims") (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type dims") (cst-list-list-conc-matchp abnf::cstss "type-variable dims"))))
Theorem:
(defthm cst-dims-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*( *annotation \"[\" \"]\" )") (or (cst-list-list-conc-matchp abnf::cstss "1*( *annotation \"[\" \"]\" )"))))
Theorem:
(defthm cst-type-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*type-parameter-modifier type-identifier [ type-bound ]") (or (cst-list-list-conc-matchp abnf::cstss "*type-parameter-modifier type-identifier [ type-bound ]"))))
Theorem:
(defthm cst-type-parameter-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation") (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))
Theorem:
(defthm cst-type-bound-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"extends\" type-variable / %s\"extends\" class-or-interface-type *additional-bound") (or (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" type-variable") (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" class-or-interface-type *additional-bound"))))
Theorem:
(defthm cst-additional-bound-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"&\" interface-type") (or (cst-list-list-conc-matchp abnf::cstss "\"&\" interface-type"))))
Theorem:
(defthm cst-type-arguments-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"<\" type-argument-list \">\"") (or (cst-list-list-conc-matchp abnf::cstss "\"<\" type-argument-list \">\""))))
Theorem:
(defthm cst-type-argument-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-argument *( \",\" type-argument )") (or (cst-list-list-conc-matchp abnf::cstss "type-argument *( \",\" type-argument )"))))
Theorem:
(defthm cst-type-argument-concs (implies (cst-list-list-alt-matchp abnf::cstss "reference-type / wildcard") (or (cst-list-list-conc-matchp abnf::cstss "reference-type") (cst-list-list-conc-matchp abnf::cstss "wildcard"))))
Theorem:
(defthm cst-wildcard-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation \"?\" [ wildcard-bounds ]") (or (cst-list-list-conc-matchp abnf::cstss "*annotation \"?\" [ wildcard-bounds ]"))))
Theorem:
(defthm cst-wildcard-bounds-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"extends\" reference-type / %s\"super\" reference-type") (or (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" reference-type") (cst-list-list-conc-matchp abnf::cstss "%s\"super\" reference-type"))))
Theorem:
(defthm cst-module-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / module-name \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "module-name \".\" identifier"))))
Theorem:
(defthm cst-package-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / package-name \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "package-name \".\" identifier"))))
Theorem:
(defthm cst-type-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-identifier / package-or-type-name \".\" type-identifier") (or (cst-list-list-conc-matchp abnf::cstss "type-identifier") (cst-list-list-conc-matchp abnf::cstss "package-or-type-name \".\" type-identifier"))))
Theorem:
(defthm cst-package-or-type-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / package-or-type-name \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "package-or-type-name \".\" identifier"))))
Theorem:
(defthm cst-expression-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / ambiguous-name \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "ambiguous-name \".\" identifier"))))
Theorem:
(defthm cst-method-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "unqualified-method-identifier") (or (cst-list-list-conc-matchp abnf::cstss "unqualified-method-identifier"))))
Theorem:
(defthm cst-ambiguous-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / ambiguous-name \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "ambiguous-name \".\" identifier"))))
Theorem:
(defthm cst-compilation-unit-concs (implies (cst-list-list-alt-matchp abnf::cstss "ordinary-compilation-unit / modular-compilation-unit") (or (cst-list-list-conc-matchp abnf::cstss "ordinary-compilation-unit") (cst-list-list-conc-matchp abnf::cstss "modular-compilation-unit"))))
Theorem:
(defthm cst-ordinary-compilation-unit-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ package-declaration ] *import-declaration *type-declaration") (or (cst-list-list-conc-matchp abnf::cstss "[ package-declaration ] *import-declaration *type-declaration"))))
Theorem:
(defthm cst-modular-compilation-unit-concs (implies (cst-list-list-alt-matchp abnf::cstss "*import-declaration module-declaration") (or (cst-list-list-conc-matchp abnf::cstss "*import-declaration module-declaration"))))
Theorem:
(defthm cst-package-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\"") (or (cst-list-list-conc-matchp abnf::cstss "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\""))))
Theorem:
(defthm cst-package-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation") (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))
Theorem:
(defthm cst-import-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "single-type-import-declaration / type-import-on-demand-declaration / single-static-import-declaration / static-import-on-demand-declaration") (or (cst-list-list-conc-matchp abnf::cstss "single-type-import-declaration") (cst-list-list-conc-matchp abnf::cstss "type-import-on-demand-declaration") (cst-list-list-conc-matchp abnf::cstss "single-static-import-declaration") (cst-list-list-conc-matchp abnf::cstss "static-import-on-demand-declaration"))))
Theorem:
(defthm cst-single-type-import-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"import\" type-name \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"import\" type-name \";\""))))
Theorem:
(defthm cst-type-import-on-demand-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"import\" package-or-type-name \".\" \"*\" \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"import\" package-or-type-name \".\" \"*\" \";\""))))
Theorem:
(defthm cst-single-static-import-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" identifier \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" identifier \";\""))))
Theorem:
(defthm cst-static-import-on-demand-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\""))))
Theorem:
(defthm cst-type-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-declaration / interface-declaration / \";\"") (or (cst-list-list-conc-matchp abnf::cstss "class-declaration") (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-module-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\""))))
Theorem:
(defthm cst-module-directive-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"requires\" *requires-modifier module-name \";\" / %s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"uses\" type-name \";\" / %s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"requires\" *requires-modifier module-name \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"uses\" type-name \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\""))))
Theorem:
(defthm cst-requires-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"transitive\" / %s\"static\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\""))))
Theorem:
(defthm cst-class-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "normal-class-declaration / enum-declaration") (or (cst-list-list-conc-matchp abnf::cstss "normal-class-declaration") (cst-list-list-conc-matchp abnf::cstss "enum-declaration"))))
Theorem:
(defthm cst-normal-class-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ superclass ] [ superinterfaces ] class-body") (or (cst-list-list-conc-matchp abnf::cstss "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ superclass ] [ superinterfaces ] class-body"))))
Theorem:
(defthm cst-class-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"strictfp\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))
Theorem:
(defthm cst-type-parameters-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"<\" type-parameter-list \">\"") (or (cst-list-list-conc-matchp abnf::cstss "\"<\" type-parameter-list \">\""))))
Theorem:
(defthm cst-type-parameter-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-parameter *( \",\" type-parameter )") (or (cst-list-list-conc-matchp abnf::cstss "type-parameter *( \",\" type-parameter )"))))
Theorem:
(defthm cst-superclass-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"extends\" class-type") (or (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" class-type"))))
Theorem:
(defthm cst-superinterfaces-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"implements\" interface-type-list") (or (cst-list-list-conc-matchp abnf::cstss "%s\"implements\" interface-type-list"))))
Theorem:
(defthm cst-interface-type-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "interface-type *( \",\" interface-type )") (or (cst-list-list-conc-matchp abnf::cstss "interface-type *( \",\" interface-type )"))))
Theorem:
(defthm cst-class-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" *class-body-declaration \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" *class-body-declaration \"}\""))))
Theorem:
(defthm cst-class-body-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-member-declaration / instance-initializer / static-initializer / constructor-declaration") (or (cst-list-list-conc-matchp abnf::cstss "class-member-declaration") (cst-list-list-conc-matchp abnf::cstss "instance-initializer") (cst-list-list-conc-matchp abnf::cstss "static-initializer") (cst-list-list-conc-matchp abnf::cstss "constructor-declaration"))))
Theorem:
(defthm cst-class-member-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "field-declaration / method-declaration / class-declaration / interface-declaration / \";\"") (or (cst-list-list-conc-matchp abnf::cstss "field-declaration") (cst-list-list-conc-matchp abnf::cstss "method-declaration") (cst-list-list-conc-matchp abnf::cstss "class-declaration") (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-field-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*field-modifier unann-type variable-declarator-list \";\"") (or (cst-list-list-conc-matchp abnf::cstss "*field-modifier unann-type variable-declarator-list \";\""))))
Theorem:
(defthm cst-variable-declarator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "variable-declarator *( \",\" variable-declarator )") (or (cst-list-list-conc-matchp abnf::cstss "variable-declarator *( \",\" variable-declarator )"))))
Theorem:
(defthm cst-variable-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "variable-declarator-id [ \"=\" variable-initializer ]") (or (cst-list-list-conc-matchp abnf::cstss "variable-declarator-id [ \"=\" variable-initializer ]"))))
Theorem:
(defthm cst-variable-declarator-id-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier [ dims ]") (or (cst-list-list-conc-matchp abnf::cstss "identifier [ dims ]"))))
Theorem:
(defthm cst-variable-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression / array-initializer") (or (cst-list-list-conc-matchp abnf::cstss "expression") (cst-list-list-conc-matchp abnf::cstss "array-initializer"))))
Theorem:
(defthm cst-unann-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-primitive-type / unann-reference-type") (or (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type") (cst-list-list-conc-matchp abnf::cstss "unann-reference-type"))))
Theorem:
(defthm cst-unann-primitive-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "numeric-type / %s\"boolean\"") (or (cst-list-list-conc-matchp abnf::cstss "numeric-type") (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\""))))
Theorem:
(defthm cst-unann-reference-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-class-or-interface-type / unann-type-variable / unann-array-type") (or (cst-list-list-conc-matchp abnf::cstss "unann-class-or-interface-type") (cst-list-list-conc-matchp abnf::cstss "unann-type-variable") (cst-list-list-conc-matchp abnf::cstss "unann-array-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-class-type / unann-interface-type") (or (cst-list-list-conc-matchp abnf::cstss "unann-class-type") (cst-list-list-conc-matchp abnf::cstss "unann-interface-type"))))
Theorem:
(defthm cst-unann-class-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]") (or (cst-list-list-conc-matchp abnf::cstss "type-identifier [ type-arguments ]") (cst-list-list-conc-matchp abnf::cstss "package-name \".\" *annotation type-identifier [ type-arguments ]") (cst-list-list-conc-matchp abnf::cstss "unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]"))))
Theorem:
(defthm cst-unann-interface-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-class-type") (or (cst-list-list-conc-matchp abnf::cstss "unann-class-type"))))
Theorem:
(defthm cst-unann-type-variable-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-identifier") (or (cst-list-list-conc-matchp abnf::cstss "type-identifier"))))
Theorem:
(defthm cst-unann-array-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-primitive-type dims / unann-class-or-interface-type dims / unann-type-variable dims") (or (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type dims") (cst-list-list-conc-matchp abnf::cstss "unann-class-or-interface-type dims") (cst-list-list-conc-matchp abnf::cstss "unann-type-variable dims"))))
Theorem:
(defthm cst-field-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"static\" / %s\"final\" / %s\"transient\" / %s\"volatile\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"") (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\""))))
Theorem:
(defthm cst-method-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*method-modifier method-header method-body") (or (cst-list-list-conc-matchp abnf::cstss "*method-modifier method-header method-body"))))
Theorem:
(defthm cst-method-header-concs (implies (cst-list-list-alt-matchp abnf::cstss "result method-declarator [ throws ] / type-parameters *annotation result method-declarator [ throws ]") (or (cst-list-list-conc-matchp abnf::cstss "result method-declarator [ throws ]") (cst-list-list-conc-matchp abnf::cstss "type-parameters *annotation result method-declarator [ throws ]"))))
Theorem:
(defthm cst-method-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]") (or (cst-list-list-conc-matchp abnf::cstss "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]"))))
Theorem:
(defthm cst-receiver-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation unann-type [ identifier \".\" ] %s\"this\"") (or (cst-list-list-conc-matchp abnf::cstss "*annotation unann-type [ identifier \".\" ] %s\"this\""))))
Theorem:
(defthm cst-formal-parameter-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "formal-parameter *( \",\" formal-parameter )") (or (cst-list-list-conc-matchp abnf::cstss "formal-parameter *( \",\" formal-parameter )"))))
Theorem:
(defthm cst-formal-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier unann-type variable-declarator-id / variable-arity-parameter") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier unann-type variable-declarator-id") (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter"))))
Theorem:
(defthm cst-variable-arity-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier unann-type *annotation \"...\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier unann-type *annotation \"...\" identifier"))))
Theorem:
(defthm cst-variable-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"final\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"final\""))))
Theorem:
(defthm cst-method-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"synchronized\" / %s\"native\" / %s\"strictfp\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"") (cst-list-list-conc-matchp abnf::cstss "%s\"native\"") (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))
Theorem:
(defthm cst-result-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"void\"") (or (cst-list-list-conc-matchp abnf::cstss "unann-type") (cst-list-list-conc-matchp abnf::cstss "%s\"void\""))))
Theorem:
(defthm cst-throws-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"throws\" exception-type-list") (or (cst-list-list-conc-matchp abnf::cstss "%s\"throws\" exception-type-list"))))
Theorem:
(defthm cst-exception-type-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "exception-type *( \",\" exception-type )") (or (cst-list-list-conc-matchp abnf::cstss "exception-type *( \",\" exception-type )"))))
Theorem:
(defthm cst-exception-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "class-type / type-variable") (or (cst-list-list-conc-matchp abnf::cstss "class-type") (cst-list-list-conc-matchp abnf::cstss "type-variable"))))
Theorem:
(defthm cst-method-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "block / \";\"") (or (cst-list-list-conc-matchp abnf::cstss "block") (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-instance-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "block") (or (cst-list-list-conc-matchp abnf::cstss "block"))))
Theorem:
(defthm cst-static-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"static\" block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"static\" block"))))
Theorem:
(defthm cst-constructor-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*constructor-modifier constructor-declarator [ throws ] constructor-body") (or (cst-list-list-conc-matchp abnf::cstss "*constructor-modifier constructor-declarator [ throws ] constructor-body"))))
Theorem:
(defthm cst-constructor-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\""))))
Theorem:
(defthm cst-simple-type-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-identifier") (or (cst-list-list-conc-matchp abnf::cstss "type-identifier"))))
Theorem:
(defthm cst-constructor-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"protected\" / %s\"private\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\""))))
Theorem:
(defthm cst-constructor-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ explicit-constructor-invocation ] [ block-statements ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ explicit-constructor-invocation ] [ block-statements ] \"}\""))))
Theorem:
(defthm cst-explicit-constructor-invocation-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\" / [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"") (or (cst-list-list-conc-matchp abnf::cstss "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\"") (cst-list-list-conc-matchp abnf::cstss "[ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"") (cst-list-list-conc-matchp abnf::cstss "expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"") (cst-list-list-conc-matchp abnf::cstss "primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\""))))
Theorem:
(defthm cst-enum-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*class-modifier %s\"enum\" type-identifier [ superinterfaces ] enum-body") (or (cst-list-list-conc-matchp abnf::cstss "*class-modifier %s\"enum\" type-identifier [ superinterfaces ] enum-body"))))
Theorem:
(defthm cst-enum-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\""))))
Theorem:
(defthm cst-enum-constant-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "enum-constant *( \",\" enum-constant )") (or (cst-list-list-conc-matchp abnf::cstss "enum-constant *( \",\" enum-constant )"))))
Theorem:
(defthm cst-enum-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]") (or (cst-list-list-conc-matchp abnf::cstss "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]"))))
Theorem:
(defthm cst-enum-constant-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation") (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))
Theorem:
(defthm cst-enum-body-declarations-concs (implies (cst-list-list-alt-matchp abnf::cstss "\";\" *class-body-declaration") (or (cst-list-list-conc-matchp abnf::cstss "\";\" *class-body-declaration"))))
Theorem:
(defthm cst-interface-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "normal-interface-declaration / annotation-type-declaration") (or (cst-list-list-conc-matchp abnf::cstss "normal-interface-declaration") (cst-list-list-conc-matchp abnf::cstss "annotation-type-declaration"))))
Theorem:
(defthm cst-normal-interface-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ extends-interfaces ] interface-body") (or (cst-list-list-conc-matchp abnf::cstss "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ extends-interfaces ] interface-body"))))
Theorem:
(defthm cst-interface-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"strictfp\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))
Theorem:
(defthm cst-extends-interfaces-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"extends\" interface-type-list") (or (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" interface-type-list"))))
Theorem:
(defthm cst-interface-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" *interface-member-declaration \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" *interface-member-declaration \"}\""))))
Theorem:
(defthm cst-interface-member-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "constant-declaration / interface-method-declaration / class-declaration / interface-declaration / \";\"") (or (cst-list-list-conc-matchp abnf::cstss "constant-declaration") (cst-list-list-conc-matchp abnf::cstss "interface-method-declaration") (cst-list-list-conc-matchp abnf::cstss "class-declaration") (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-constant-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*constant-modifier unann-type variable-declarator-list \";\"") (or (cst-list-list-conc-matchp abnf::cstss "*constant-modifier unann-type variable-declarator-list \";\""))))
Theorem:
(defthm cst-constant-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"static\" / %s\"final\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"final\""))))
Theorem:
(defthm cst-interface-method-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*interface-method-modifier method-header method-body") (or (cst-list-list-conc-matchp abnf::cstss "*interface-method-modifier method-header method-body"))))
Theorem:
(defthm cst-interface-method-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"private\" / %s\"abstract\" / %s\"default\" / %s\"static\" / %s\"strictfp\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (cst-list-list-conc-matchp abnf::cstss "%s\"default\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))
Theorem:
(defthm cst-annotation-type-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-type-body") (or (cst-list-list-conc-matchp abnf::cstss "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-type-body"))))
Theorem:
(defthm cst-annotation-type-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" *annotation-type-member-declaration \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" *annotation-type-member-declaration \"}\""))))
Theorem:
(defthm cst-annotation-type-member-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation-type-element-declaration / constant-declaration / class-declaration / interface-declaration / \";\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation-type-element-declaration") (cst-list-list-conc-matchp abnf::cstss "constant-declaration") (cst-list-list-conc-matchp abnf::cstss "class-declaration") (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-annotation-type-element-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation-type-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "*annotation-type-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\""))))
Theorem:
(defthm cst-annotation-type-element-modifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"public\" / %s\"abstract\"") (or (cst-list-list-conc-matchp abnf::cstss "annotation") (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\""))))
Theorem:
(defthm cst-default-value-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"default\" element-value") (or (cst-list-list-conc-matchp abnf::cstss "%s\"default\" element-value"))))
Theorem:
(defthm cst-annotation-concs (implies (cst-list-list-alt-matchp abnf::cstss "normal-annotation / marker-annotation / single-element-annotation") (or (cst-list-list-conc-matchp abnf::cstss "normal-annotation") (cst-list-list-conc-matchp abnf::cstss "marker-annotation") (cst-list-list-conc-matchp abnf::cstss "single-element-annotation"))))
Theorem:
(defthm cst-normal-annotation-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"@\" type-name \"(\" [ element-value-pair-list ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name \"(\" [ element-value-pair-list ] \")\""))))
Theorem:
(defthm cst-element-value-pair-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "element-value-pair *( \",\" element-value-pair )") (or (cst-list-list-conc-matchp abnf::cstss "element-value-pair *( \",\" element-value-pair )"))))
Theorem:
(defthm cst-element-value-pair-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier \"=\" element-value") (or (cst-list-list-conc-matchp abnf::cstss "identifier \"=\" element-value"))))
Theorem:
(defthm cst-element-value-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-expression / element-value-array-initializer / annotation") (or (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (cst-list-list-conc-matchp abnf::cstss "element-value-array-initializer") (cst-list-list-conc-matchp abnf::cstss "annotation"))))
Theorem:
(defthm cst-element-value-array-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ element-value-list ] [ \",\" ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ element-value-list ] [ \",\" ] \"}\""))))
Theorem:
(defthm cst-element-value-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "element-value *( \",\" element-value )") (or (cst-list-list-conc-matchp abnf::cstss "element-value *( \",\" element-value )"))))
Theorem:
(defthm cst-marker-annotation-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"@\" type-name") (or (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name"))))
Theorem:
(defthm cst-single-element-annotation-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"@\" type-name \"(\" element-value \")\"") (or (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name \"(\" element-value \")\""))))
Theorem:
(defthm cst-array-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\""))))
Theorem:
(defthm cst-variable-initializer-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "variable-initializer *( \",\" variable-initializer )") (or (cst-list-list-conc-matchp abnf::cstss "variable-initializer *( \",\" variable-initializer )"))))
Theorem:
(defthm cst-block-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ block-statements ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ block-statements ] \"}\""))))
Theorem:
(defthm cst-block-statements-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*block-statement") (or (cst-list-list-conc-matchp abnf::cstss "1*block-statement"))))
Theorem:
(defthm cst-block-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "local-variable-declaration-statement / class-declaration / statement") (or (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration-statement") (cst-list-list-conc-matchp abnf::cstss "class-declaration") (cst-list-list-conc-matchp abnf::cstss "statement"))))
Theorem:
(defthm cst-local-variable-declaration-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "local-variable-declaration \";\"") (or (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration \";\""))))
Theorem:
(defthm cst-local-variable-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier local-variable-type variable-declarator-list") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier local-variable-type variable-declarator-list"))))
Theorem:
(defthm cst-local-variable-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"var\"") (or (cst-list-list-conc-matchp abnf::cstss "unann-type") (cst-list-list-conc-matchp abnf::cstss "%s\"var\""))))
Theorem:
(defthm cst-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-without-trailing-substatement / labeled-statement / if-then-statement / if-then-else-statement / while-statement / for-statement") (or (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement") (cst-list-list-conc-matchp abnf::cstss "labeled-statement") (cst-list-list-conc-matchp abnf::cstss "if-then-statement") (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement") (cst-list-list-conc-matchp abnf::cstss "while-statement") (cst-list-list-conc-matchp abnf::cstss "for-statement"))))
Theorem:
(defthm cst-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-without-trailing-substatement / labeled-statement-no-short-if / if-then-else-statement-no-short-if / while-statement-no-short-if / for-statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement") (cst-list-list-conc-matchp abnf::cstss "labeled-statement-no-short-if") (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement-no-short-if") (cst-list-list-conc-matchp abnf::cstss "while-statement-no-short-if") (cst-list-list-conc-matchp abnf::cstss "for-statement-no-short-if"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-concs (implies (cst-list-list-alt-matchp abnf::cstss "block / empty-statement / expression-statement / assert-statement / switch-statement / do-statement / break-statement / continue-statement / return-statement / synchronized-statement / throw-statement / try-statement / yield-statement") (or (cst-list-list-conc-matchp abnf::cstss "block") (cst-list-list-conc-matchp abnf::cstss "empty-statement") (cst-list-list-conc-matchp abnf::cstss "expression-statement") (cst-list-list-conc-matchp abnf::cstss "assert-statement") (cst-list-list-conc-matchp abnf::cstss "switch-statement") (cst-list-list-conc-matchp abnf::cstss "do-statement") (cst-list-list-conc-matchp abnf::cstss "break-statement") (cst-list-list-conc-matchp abnf::cstss "continue-statement") (cst-list-list-conc-matchp abnf::cstss "return-statement") (cst-list-list-conc-matchp abnf::cstss "synchronized-statement") (cst-list-list-conc-matchp abnf::cstss "throw-statement") (cst-list-list-conc-matchp abnf::cstss "try-statement") (cst-list-list-conc-matchp abnf::cstss "yield-statement"))))
Theorem:
(defthm cst-empty-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "\";\"") (or (cst-list-list-conc-matchp abnf::cstss "\";\""))))
Theorem:
(defthm cst-labeled-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier \":\" statement") (or (cst-list-list-conc-matchp abnf::cstss "identifier \":\" statement"))))
Theorem:
(defthm cst-labeled-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier \":\" statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "identifier \":\" statement-no-short-if"))))
Theorem:
(defthm cst-expression-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-expression \";\"") (or (cst-list-list-conc-matchp abnf::cstss "statement-expression \";\""))))
Theorem:
(defthm cst-statement-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "assignment / pre-increment-expression / pre-decrement-expression / post-increment-expression / post-decrement-expression / method-invocation / class-instance-creation-expression") (or (cst-list-list-conc-matchp abnf::cstss "assignment") (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression") (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression") (cst-list-list-conc-matchp abnf::cstss "post-increment-expression") (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression") (cst-list-list-conc-matchp abnf::cstss "method-invocation") (cst-list-list-conc-matchp abnf::cstss "class-instance-creation-expression"))))
Theorem:
(defthm cst-if-then-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement"))))
Theorem:
(defthm cst-if-then-else-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement"))))
Theorem:
(defthm cst-if-then-else-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if"))))
Theorem:
(defthm cst-assert-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"assert\" expression \";\" / %s\"assert\" expression \":\" expression \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"assert\" expression \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"assert\" expression \":\" expression \";\""))))
Theorem:
(defthm cst-switch-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block"))))
Theorem:
(defthm cst-switch-block-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" 1*switch-rule \"}\" / \"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" 1*switch-rule \"}\"") (cst-list-list-conc-matchp abnf::cstss "\"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\""))))
Theorem:
(defthm cst-switch-rule-concs (implies (cst-list-list-alt-matchp abnf::cstss "switch-label \"->\" expression \";\" / switch-label \"->\" block / switch-label \"->\" throw-statement") (or (cst-list-list-conc-matchp abnf::cstss "switch-label \"->\" expression \";\"") (cst-list-list-conc-matchp abnf::cstss "switch-label \"->\" block") (cst-list-list-conc-matchp abnf::cstss "switch-label \"->\" throw-statement"))))
Theorem:
(defthm cst-switch-block-statement-group-concs (implies (cst-list-list-alt-matchp abnf::cstss "switch-label \":\" *( switch-label \":\" ) block-statements") (or (cst-list-list-conc-matchp abnf::cstss "switch-label \":\" *( switch-label \":\" ) block-statements"))))
Theorem:
(defthm cst-switch-label-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"case\" case-constant *( \",\" case-constant ) / %s\"default\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"case\" case-constant *( \",\" case-constant )") (cst-list-list-conc-matchp abnf::cstss "%s\"default\""))))
Theorem:
(defthm cst-case-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-expression") (or (cst-list-list-conc-matchp abnf::cstss "conditional-expression"))))
Theorem:
(defthm cst-while-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement"))))
Theorem:
(defthm cst-while-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement-no-short-if"))))
Theorem:
(defthm cst-do-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\""))))
Theorem:
(defthm cst-for-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-for-statement / enhanced-for-statement") (or (cst-list-list-conc-matchp abnf::cstss "basic-for-statement") (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement"))))
Theorem:
(defthm cst-for-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-for-statement-no-short-if / enhanced-for-statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "basic-for-statement-no-short-if") (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement-no-short-if"))))
Theorem:
(defthm cst-basic-for-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement"))))
Theorem:
(defthm cst-basic-for-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if"))))
Theorem:
(defthm cst-for-init-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-expression-list / local-variable-declaration") (or (cst-list-list-conc-matchp abnf::cstss "statement-expression-list") (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration"))))
Theorem:
(defthm cst-for-update-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-expression-list") (or (cst-list-list-conc-matchp abnf::cstss "statement-expression-list"))))
Theorem:
(defthm cst-statement-expression-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "statement-expression *( \",\" statement-expression )") (or (cst-list-list-conc-matchp abnf::cstss "statement-expression *( \",\" statement-expression )"))))
Theorem:
(defthm cst-enhanced-for-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement"))))
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement-no-short-if") (or (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement-no-short-if"))))
Theorem:
(defthm cst-break-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"break\" [ identifier ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"break\" [ identifier ] \";\""))))
Theorem:
(defthm cst-continue-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"continue\" [ identifier ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"continue\" [ identifier ] \";\""))))
Theorem:
(defthm cst-return-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"return\" [ expression ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"return\" [ expression ] \";\""))))
Theorem:
(defthm cst-throw-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"throw\" expression \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"throw\" expression \";\""))))
Theorem:
(defthm cst-synchronized-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"synchronized\" \"(\" expression \")\" block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\" \"(\" expression \")\" block"))))
Theorem:
(defthm cst-try-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"try\" block catches / %s\"try\" block [ catches ] finally / try-with-resources-statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"try\" block catches") (cst-list-list-conc-matchp abnf::cstss "%s\"try\" block [ catches ] finally") (cst-list-list-conc-matchp abnf::cstss "try-with-resources-statement"))))
Theorem:
(defthm cst-catches-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*catch-clause") (or (cst-list-list-conc-matchp abnf::cstss "1*catch-clause"))))
Theorem:
(defthm cst-catch-clause-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"catch\" \"(\" catch-formal-parameter \")\" block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"catch\" \"(\" catch-formal-parameter \")\" block"))))
Theorem:
(defthm cst-catch-formal-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier catch-type variable-declarator-id") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier catch-type variable-declarator-id"))))
Theorem:
(defthm cst-catch-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-class-type *( \"|\" class-type )") (or (cst-list-list-conc-matchp abnf::cstss "unann-class-type *( \"|\" class-type )"))))
Theorem:
(defthm cst-finally-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"finally\" block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"finally\" block"))))
Theorem:
(defthm cst-try-with-resources-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"try\" resource-specification block [ catches ] [ finally ]") (or (cst-list-list-conc-matchp abnf::cstss "%s\"try\" resource-specification block [ catches ] [ finally ]"))))
Theorem:
(defthm cst-resource-specification-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" resource-list [ \";\" ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" resource-list [ \";\" ] \")\""))))
Theorem:
(defthm cst-resource-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "resource *( \";\" resource )") (or (cst-list-list-conc-matchp abnf::cstss "resource *( \";\" resource )"))))
Theorem:
(defthm cst-resource-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier local-variable-type identifier \"=\" expression / variable-access") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier local-variable-type identifier \"=\" expression") (cst-list-list-conc-matchp abnf::cstss "variable-access"))))
Theorem:
(defthm cst-variable-access-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression-name / field-access") (or (cst-list-list-conc-matchp abnf::cstss "expression-name") (cst-list-list-conc-matchp abnf::cstss "field-access"))))
Theorem:
(defthm cst-yield-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"yield\" expression \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"yield\" expression \";\""))))
Theorem:
(defthm cst-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "lambda-expression / assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "lambda-expression") (cst-list-list-conc-matchp abnf::cstss "assignment-expression"))))
Theorem:
(defthm cst-primary-concs (implies (cst-list-list-alt-matchp abnf::cstss "primary-no-new-array / array-creation-expression") (or (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array") (cst-list-list-conc-matchp abnf::cstss "array-creation-expression"))))
Theorem:
(defthm cst-primary-no-new-array-concs (implies (cst-list-list-alt-matchp abnf::cstss "literal / class-literal / %s\"this\" / type-name \".\" %s\"this\" / \"(\" expression \")\" / class-instance-creation-expression / field-access / array-access / method-invocation / method-reference") (or (cst-list-list-conc-matchp abnf::cstss "literal") (cst-list-list-conc-matchp abnf::cstss "class-literal") (cst-list-list-conc-matchp abnf::cstss "%s\"this\"") (cst-list-list-conc-matchp abnf::cstss "type-name \".\" %s\"this\"") (cst-list-list-conc-matchp abnf::cstss "\"(\" expression \")\"") (cst-list-list-conc-matchp abnf::cstss "class-instance-creation-expression") (cst-list-list-conc-matchp abnf::cstss "field-access") (cst-list-list-conc-matchp abnf::cstss "array-access") (cst-list-list-conc-matchp abnf::cstss "method-invocation") (cst-list-list-conc-matchp abnf::cstss "method-reference"))))
Theorem:
(defthm cst-class-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-name *( \"[\" \"]\" ) \".\" %s\"class\" / numeric-type *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"void\" \".\" %s\"class\"") (or (cst-list-list-conc-matchp abnf::cstss "type-name *( \"[\" \"]\" ) \".\" %s\"class\"") (cst-list-list-conc-matchp abnf::cstss "numeric-type *( \"[\" \"]\" ) \".\" %s\"class\"") (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\"") (cst-list-list-conc-matchp abnf::cstss "%s\"void\" \".\" %s\"class\""))))
Theorem:
(defthm cst-class-instance-creation-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "unqualified-class-instance-creation-expression / expression-name \".\" unqualified-class-instance-creation-expression / primary \".\" unqualified-class-instance-creation-expression") (or (cst-list-list-conc-matchp abnf::cstss "unqualified-class-instance-creation-expression") (cst-list-list-conc-matchp abnf::cstss "expression-name \".\" unqualified-class-instance-creation-expression") (cst-list-list-conc-matchp abnf::cstss "primary \".\" unqualified-class-instance-creation-expression"))))
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]") (or (cst-list-list-conc-matchp abnf::cstss "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]"))))
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]") (or (cst-list-list-conc-matchp abnf::cstss "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]"))))
Theorem:
(defthm cst-type-arguments-or-diamond-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-arguments / \"<>\"") (or (cst-list-list-conc-matchp abnf::cstss "type-arguments") (cst-list-list-conc-matchp abnf::cstss "\"<>\""))))
Theorem:
(defthm cst-array-creation-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"new\" primitive-type dim-exprs [ dims ] / %s\"new\" class-or-interface-type dim-exprs [ dims ] / %s\"new\" primitive-type dims array-initializer / %s\"new\" class-or-interface-type dims array-initializer") (or (cst-list-list-conc-matchp abnf::cstss "%s\"new\" primitive-type dim-exprs [ dims ]") (cst-list-list-conc-matchp abnf::cstss "%s\"new\" class-or-interface-type dim-exprs [ dims ]") (cst-list-list-conc-matchp abnf::cstss "%s\"new\" primitive-type dims array-initializer") (cst-list-list-conc-matchp abnf::cstss "%s\"new\" class-or-interface-type dims array-initializer"))))
Theorem:
(defthm cst-dim-exprs-concs (implies (cst-list-list-alt-matchp abnf::cstss "1*dim-expr") (or (cst-list-list-conc-matchp abnf::cstss "1*dim-expr"))))
Theorem:
(defthm cst-dim-expr-concs (implies (cst-list-list-alt-matchp abnf::cstss "*annotation \"[\" expression \"]\"") (or (cst-list-list-conc-matchp abnf::cstss "*annotation \"[\" expression \"]\""))))
Theorem:
(defthm cst-array-access-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression-name \"[\" expression \"]\" / primary-no-new-array \"[\" expression \"]\"") (or (cst-list-list-conc-matchp abnf::cstss "expression-name \"[\" expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array \"[\" expression \"]\""))))
Theorem:
(defthm cst-field-access-concs (implies (cst-list-list-alt-matchp abnf::cstss "primary \".\" identifier / %s\"super\" \".\" identifier / type-name \".\" %s\"super\" \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "primary \".\" identifier") (cst-list-list-conc-matchp abnf::cstss "%s\"super\" \".\" identifier") (cst-list-list-conc-matchp abnf::cstss "type-name \".\" %s\"super\" \".\" identifier"))))
Theorem:
(defthm cst-method-invocation-concs (implies (cst-list-list-alt-matchp abnf::cstss "method-name \"(\" [ argument-list ] \")\" / type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "method-name \"(\" [ argument-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "%s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\""))))
Theorem:
(defthm cst-argument-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression *( \",\" expression )") (or (cst-list-list-conc-matchp abnf::cstss "expression *( \",\" expression )"))))
Theorem:
(defthm cst-method-reference-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression-name \"::\" [ type-arguments ] identifier / primary \"::\" [ type-arguments ] identifier / reference-type \"::\" [ type-arguments ] identifier / %s\"super\" \"::\" [ type-arguments ] identifier / type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier / class-type \"::\" [ type-arguments ] %s\"new\" / array-type \"::\" %s\"new\"") (or (cst-list-list-conc-matchp abnf::cstss "expression-name \"::\" [ type-arguments ] identifier") (cst-list-list-conc-matchp abnf::cstss "primary \"::\" [ type-arguments ] identifier") (cst-list-list-conc-matchp abnf::cstss "reference-type \"::\" [ type-arguments ] identifier") (cst-list-list-conc-matchp abnf::cstss "%s\"super\" \"::\" [ type-arguments ] identifier") (cst-list-list-conc-matchp abnf::cstss "type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier") (cst-list-list-conc-matchp abnf::cstss "class-type \"::\" [ type-arguments ] %s\"new\"") (cst-list-list-conc-matchp abnf::cstss "array-type \"::\" %s\"new\""))))
Theorem:
(defthm cst-postfix-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "primary / expression-name / post-increment-expression / post-decrement-expression") (or (cst-list-list-conc-matchp abnf::cstss "primary") (cst-list-list-conc-matchp abnf::cstss "expression-name") (cst-list-list-conc-matchp abnf::cstss "post-increment-expression") (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression"))))
Theorem:
(defthm cst-post-increment-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "postfix-expression \"++\"") (or (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"++\""))))
Theorem:
(defthm cst-post-decrement-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "postfix-expression \"--\"") (or (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"--\""))))
Theorem:
(defthm cst-unary-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "pre-increment-expression / pre-decrement-expression / \"+\" unary-expression / \"-\" unary-expression / unary-expression-not-plus-minus") (or (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression") (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression") (cst-list-list-conc-matchp abnf::cstss "\"+\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "\"-\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "unary-expression-not-plus-minus"))))
Theorem:
(defthm cst-pre-increment-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"++\" unary-expression") (or (cst-list-list-conc-matchp abnf::cstss "\"++\" unary-expression"))))
Theorem:
(defthm cst-pre-decrement-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"--\" unary-expression") (or (cst-list-list-conc-matchp abnf::cstss "\"--\" unary-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-concs (implies (cst-list-list-alt-matchp abnf::cstss "postfix-expression / \"~\" unary-expression / \"!\" unary-expression / cast-expression / switch-expression") (or (cst-list-list-conc-matchp abnf::cstss "postfix-expression") (cst-list-list-conc-matchp abnf::cstss "\"~\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "\"!\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "cast-expression") (cst-list-list-conc-matchp abnf::cstss "switch-expression"))))
Theorem:
(defthm cst-cast-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" primitive-type \")\" unary-expression / \"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus / \"(\" reference-type *additional-bound \")\" lambda-expression") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" primitive-type \")\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "\"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus") (cst-list-list-conc-matchp abnf::cstss "\"(\" reference-type *additional-bound \")\" lambda-expression"))))
Theorem:
(defthm cst-multiplicative-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "unary-expression / multiplicative-expression \"*\" unary-expression / multiplicative-expression \"/\" unary-expression / multiplicative-expression \"%\" unary-expression") (or (cst-list-list-conc-matchp abnf::cstss "unary-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"*\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"/\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"%\" unary-expression"))))
Theorem:
(defthm cst-additive-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "multiplicative-expression / additive-expression \"+\" multiplicative-expression / additive-expression \"-\" multiplicative-expression") (or (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression") (cst-list-list-conc-matchp abnf::cstss "additive-expression \"+\" multiplicative-expression") (cst-list-list-conc-matchp abnf::cstss "additive-expression \"-\" multiplicative-expression"))))
Theorem:
(defthm cst-shift-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "additive-expression / shift-expression \"<<\" additive-expression / shift-expression \">>\" additive-expression / shift-expression \">>>\" additive-expression") (or (cst-list-list-conc-matchp abnf::cstss "additive-expression") (cst-list-list-conc-matchp abnf::cstss "shift-expression \"<<\" additive-expression") (cst-list-list-conc-matchp abnf::cstss "shift-expression \">>\" additive-expression") (cst-list-list-conc-matchp abnf::cstss "shift-expression \">>>\" additive-expression"))))
Theorem:
(defthm cst-relational-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "shift-expression / relational-expression \"<\" shift-expression / relational-expression \">\" shift-expression / relational-expression \"<=\" shift-expression / relational-expression \">=\" shift-expression / relational-expression %s\"instanceof\" reference-type") (or (cst-list-list-conc-matchp abnf::cstss "shift-expression") (cst-list-list-conc-matchp abnf::cstss "relational-expression \"<\" shift-expression") (cst-list-list-conc-matchp abnf::cstss "relational-expression \">\" shift-expression") (cst-list-list-conc-matchp abnf::cstss "relational-expression \"<=\" shift-expression") (cst-list-list-conc-matchp abnf::cstss "relational-expression \">=\" shift-expression") (cst-list-list-conc-matchp abnf::cstss "relational-expression %s\"instanceof\" reference-type"))))
Theorem:
(defthm cst-equality-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "relational-expression / equality-expression \"==\" relational-expression / equality-expression \"!=\" relational-expression") (or (cst-list-list-conc-matchp abnf::cstss "relational-expression") (cst-list-list-conc-matchp abnf::cstss "equality-expression \"==\" relational-expression") (cst-list-list-conc-matchp abnf::cstss "equality-expression \"!=\" relational-expression"))))
Theorem:
(defthm cst-and-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "equality-expression / and-expression \"&\" equality-expression") (or (cst-list-list-conc-matchp abnf::cstss "equality-expression") (cst-list-list-conc-matchp abnf::cstss "and-expression \"&\" equality-expression"))))
Theorem:
(defthm cst-exclusive-or-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "and-expression / exclusive-or-expression \"^\" and-expression") (or (cst-list-list-conc-matchp abnf::cstss "and-expression") (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression \"^\" and-expression"))))
Theorem:
(defthm cst-inclusive-or-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "exclusive-or-expression / inclusive-or-expression \"|\" exclusive-or-expression") (or (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression") (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression \"|\" exclusive-or-expression"))))
Theorem:
(defthm cst-conditional-and-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "inclusive-or-expression / conditional-and-expression \"&&\" inclusive-or-expression") (or (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression") (cst-list-list-conc-matchp abnf::cstss "conditional-and-expression \"&&\" inclusive-or-expression"))))
Theorem:
(defthm cst-conditional-or-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-and-expression / conditional-or-expression \"||\" conditional-and-expression") (or (cst-list-list-conc-matchp abnf::cstss "conditional-and-expression") (cst-list-list-conc-matchp abnf::cstss "conditional-or-expression \"||\" conditional-and-expression"))))
Theorem:
(defthm cst-conditional-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-or-expression / conditional-or-expression \"?\" expression \":\" conditional-expression / conditional-or-expression \"?\" expression \":\" lambda-expression") (or (cst-list-list-conc-matchp abnf::cstss "conditional-or-expression") (cst-list-list-conc-matchp abnf::cstss "conditional-or-expression \"?\" expression \":\" conditional-expression") (cst-list-list-conc-matchp abnf::cstss "conditional-or-expression \"?\" expression \":\" lambda-expression"))))
Theorem:
(defthm cst-assignment-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-expression / assignment") (or (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (cst-list-list-conc-matchp abnf::cstss "assignment"))))
Theorem:
(defthm cst-assignment-concs (implies (cst-list-list-alt-matchp abnf::cstss "left-hand-side assignment-operator expression") (or (cst-list-list-conc-matchp abnf::cstss "left-hand-side assignment-operator expression"))))
Theorem:
(defthm cst-left-hand-side-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression-name / field-access / array-access") (or (cst-list-list-conc-matchp abnf::cstss "expression-name") (cst-list-list-conc-matchp abnf::cstss "field-access") (cst-list-list-conc-matchp abnf::cstss "array-access"))))
Theorem:
(defthm cst-assignment-operator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"=\" / \"*=\" / \"/=\" / \"%=\" / \"+=\" / \"-=\" / \"<<=\" / \">>=\" / \">>>=\" / \"&=\" / \"^=\" / \"|=\"") (or (cst-list-list-conc-matchp abnf::cstss "\"=\"") (cst-list-list-conc-matchp abnf::cstss "\"*=\"") (cst-list-list-conc-matchp abnf::cstss "\"/=\"") (cst-list-list-conc-matchp abnf::cstss "\"%=\"") (cst-list-list-conc-matchp abnf::cstss "\"+=\"") (cst-list-list-conc-matchp abnf::cstss "\"-=\"") (cst-list-list-conc-matchp abnf::cstss "\"<<=\"") (cst-list-list-conc-matchp abnf::cstss "\">>=\"") (cst-list-list-conc-matchp abnf::cstss "\">>>=\"") (cst-list-list-conc-matchp abnf::cstss "\"&=\"") (cst-list-list-conc-matchp abnf::cstss "\"^=\"") (cst-list-list-conc-matchp abnf::cstss "\"|=\""))))
Theorem:
(defthm cst-lambda-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "lambda-parameters \"->\" lambda-body") (or (cst-list-list-conc-matchp abnf::cstss "lambda-parameters \"->\" lambda-body"))))
Theorem:
(defthm cst-lambda-parameters-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" [ lambda-parameter-list ] \")\" / identifier") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" [ lambda-parameter-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "identifier"))))
Theorem:
(defthm cst-lambda-parameter-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "lambda-parameter *( \",\" lambda-parameter ) / identifier *( \",\" identifier )") (or (cst-list-list-conc-matchp abnf::cstss "lambda-parameter *( \",\" lambda-parameter )") (cst-list-list-conc-matchp abnf::cstss "identifier *( \",\" identifier )"))))
Theorem:
(defthm cst-lambda-parameter-concs (implies (cst-list-list-alt-matchp abnf::cstss "*variable-modifier lambda-parameter-type variable-declarator-id / variable-arity-parameter") (or (cst-list-list-conc-matchp abnf::cstss "*variable-modifier lambda-parameter-type variable-declarator-id") (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter"))))
Theorem:
(defthm cst-lambda-parameter-type-concs (implies (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"var\"") (or (cst-list-list-conc-matchp abnf::cstss "unann-type") (cst-list-list-conc-matchp abnf::cstss "%s\"var\""))))
Theorem:
(defthm cst-lambda-body-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression / block") (or (cst-list-list-conc-matchp abnf::cstss "expression") (cst-list-list-conc-matchp abnf::cstss "block"))))
Theorem:
(defthm cst-switch-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block") (or (cst-list-list-conc-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block"))))
Theorem:
(defthm cst-constant-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "expression") (or (cst-list-list-conc-matchp abnf::cstss "expression"))))
Theorem:
(defthm cst-unicode-input-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unicode-escape") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unicode-escape"))))
Theorem:
(defthm cst-unicode-input-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "raw-input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "raw-input-character"))))
Theorem:
(defthm cst-unicode-marker-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*%s\"u\""))))
Theorem:
(defthm cst-hex-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-hex-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-hex-digit-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"2\""))))
Theorem:
(defthm cst-hex-digit-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"3\""))))
Theorem:
(defthm cst-hex-digit-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"4\""))))
Theorem:
(defthm cst-hex-digit-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"5\""))))
Theorem:
(defthm cst-hex-digit-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"6\""))))
Theorem:
(defthm cst-hex-digit-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"7\""))))
Theorem:
(defthm cst-hex-digit-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"8\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"8\""))))
Theorem:
(defthm cst-hex-digit-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"9\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"9\""))))
Theorem:
(defthm cst-hex-digit-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"a\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"a\""))))
Theorem:
(defthm cst-hex-digit-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"b\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"b\""))))
Theorem:
(defthm cst-hex-digit-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"c\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"c\""))))
Theorem:
(defthm cst-hex-digit-conc14-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"d\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"d\""))))
Theorem:
(defthm cst-hex-digit-conc15-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"e\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"e\""))))
Theorem:
(defthm cst-hex-digit-conc16-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"f\""))))
Theorem:
(defthm cst-raw-input-character-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x0-FFFF"))))
Theorem:
(defthm cst-line-terminator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d10") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d10"))))
Theorem:
(defthm cst-line-terminator-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d13") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d13"))))
Theorem:
(defthm cst-line-terminator-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d13.10") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d13.10"))))
Theorem:
(defthm cst-input-character-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "unicode-input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unicode-input-character"))))
Theorem:
(defthm cst-input-element-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "white-space") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "white-space"))))
Theorem:
(defthm cst-input-element-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "comment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "comment"))))
Theorem:
(defthm cst-input-element-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "token") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "token"))))
Theorem:
(defthm cst-token-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-token-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "keyword") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "keyword"))))
Theorem:
(defthm cst-token-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "literal"))))
Theorem:
(defthm cst-token-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "separator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "separator"))))
Theorem:
(defthm cst-token-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "operator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "operator"))))
Theorem:
(defthm cst-sub-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d26") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d26"))))
Theorem:
(defthm cst-white-space-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d32") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d32"))))
Theorem:
(defthm cst-white-space-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d9") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d9"))))
Theorem:
(defthm cst-white-space-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%d12") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%d12"))))
Theorem:
(defthm cst-white-space-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-terminator"))))
Theorem:
(defthm cst-comment-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "traditional-comment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "traditional-comment"))))
Theorem:
(defthm cst-comment-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "end-of-line-comment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "end-of-line-comment"))))
Theorem:
(defthm cst-comment-tail-star-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"/\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"/\""))))
Theorem:
(defthm cst-not-star-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "input-character"))))
Theorem:
(defthm cst-not-star-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-terminator"))))
Theorem:
(defthm cst-not-star-not-slash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "input-character"))))
Theorem:
(defthm cst-not-star-not-slash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-terminator"))))
Theorem:
(defthm cst-identifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier-chars") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier-chars"))))
Theorem:
(defthm cst-java-letter-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "raw-input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "raw-input-character"))))
Theorem:
(defthm cst-java-letter-or-digit-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "raw-input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "raw-input-character"))))
Theorem:
(defthm cst-type-identifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-unqualified-method-identifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-keyword-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-keyword-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"assert\""))))
Theorem:
(defthm cst-keyword-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"boolean\""))))
Theorem:
(defthm cst-keyword-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"break\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"break\""))))
Theorem:
(defthm cst-keyword-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"byte\""))))
Theorem:
(defthm cst-keyword-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"case\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"case\""))))
Theorem:
(defthm cst-keyword-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"catch\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"catch\""))))
Theorem:
(defthm cst-keyword-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"char\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"char\""))))
Theorem:
(defthm cst-keyword-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"class\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"class\""))))
Theorem:
(defthm cst-keyword-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"const\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"const\""))))
Theorem:
(defthm cst-keyword-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"continue\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"continue\""))))
Theorem:
(defthm cst-keyword-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"default\""))))
Theorem:
(defthm cst-keyword-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"do\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"do\""))))
Theorem:
(defthm cst-keyword-conc14-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"double\""))))
Theorem:
(defthm cst-keyword-conc15-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"else\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"else\""))))
Theorem:
(defthm cst-keyword-conc16-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"enum\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"enum\""))))
Theorem:
(defthm cst-keyword-conc17-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"extends\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"extends\""))))
Theorem:
(defthm cst-keyword-conc18-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-keyword-conc19-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"finally\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"finally\""))))
Theorem:
(defthm cst-keyword-conc20-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"float\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"float\""))))
Theorem:
(defthm cst-keyword-conc21-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"for\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"for\""))))
Theorem:
(defthm cst-keyword-conc22-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"if\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"if\""))))
Theorem:
(defthm cst-keyword-conc23-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"goto\""))))
Theorem:
(defthm cst-keyword-conc24-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"implements\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"implements\""))))
Theorem:
(defthm cst-keyword-conc25-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"import\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"import\""))))
Theorem:
(defthm cst-keyword-conc26-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"instanceof\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"instanceof\""))))
Theorem:
(defthm cst-keyword-conc27-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"int\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"int\""))))
Theorem:
(defthm cst-keyword-conc28-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"interface\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"interface\""))))
Theorem:
(defthm cst-keyword-conc29-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"long\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"long\""))))
Theorem:
(defthm cst-keyword-conc30-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"native\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"native\""))))
Theorem:
(defthm cst-keyword-conc31-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"new\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"new\""))))
Theorem:
(defthm cst-keyword-conc32-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"package\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"package\""))))
Theorem:
(defthm cst-keyword-conc33-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-keyword-conc34-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-keyword-conc35-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-keyword-conc36-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"return\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"return\""))))
Theorem:
(defthm cst-keyword-conc37-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"short\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"short\""))))
Theorem:
(defthm cst-keyword-conc38-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-keyword-conc39-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"strictfp\""))))
Theorem:
(defthm cst-keyword-conc40-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"super\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"super\""))))
Theorem:
(defthm cst-keyword-conc41-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"switch\""))))
Theorem:
(defthm cst-keyword-conc42-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"synchronized\""))))
Theorem:
(defthm cst-keyword-conc43-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"this\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"this\""))))
Theorem:
(defthm cst-keyword-conc44-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"throw\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"throw\""))))
Theorem:
(defthm cst-keyword-conc45-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"throws\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"throws\""))))
Theorem:
(defthm cst-keyword-conc46-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"transient\""))))
Theorem:
(defthm cst-keyword-conc47-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"try\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"try\""))))
Theorem:
(defthm cst-keyword-conc48-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"void\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"void\""))))
Theorem:
(defthm cst-keyword-conc49-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"volatile\""))))
Theorem:
(defthm cst-keyword-conc50-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"while\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"while\""))))
Theorem:
(defthm cst-keyword-conc51-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"_\""))))
Theorem:
(defthm cst-literal-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "integer-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "integer-literal"))))
Theorem:
(defthm cst-literal-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "floating-point-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "floating-point-literal"))))
Theorem:
(defthm cst-literal-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "boolean-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "boolean-literal"))))
Theorem:
(defthm cst-literal-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "character-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "character-literal"))))
Theorem:
(defthm cst-literal-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "string-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "string-literal"))))
Theorem:
(defthm cst-literal-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "null-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "null-literal"))))
Theorem:
(defthm cst-integer-literal-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "decimal-integer-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "decimal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "hex-integer-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hex-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "octal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "binary-integer-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "binary-integer-literal"))))
Theorem:
(defthm cst-integer-type-suffix-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"l\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"l\""))))
Theorem:
(defthm cst-decimal-numeral-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-non-zero-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-non-zero-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"2\""))))
Theorem:
(defthm cst-non-zero-digit-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"3\""))))
Theorem:
(defthm cst-non-zero-digit-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"4\""))))
Theorem:
(defthm cst-non-zero-digit-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"5\""))))
Theorem:
(defthm cst-non-zero-digit-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"6\""))))
Theorem:
(defthm cst-non-zero-digit-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"7\""))))
Theorem:
(defthm cst-non-zero-digit-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"8\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"8\""))))
Theorem:
(defthm cst-non-zero-digit-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"9\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"9\""))))
Theorem:
(defthm cst-digits-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "non-zero-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "non-zero-digit"))))
Theorem:
(defthm cst-digit-or-underscore-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-digit-or-underscore-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"_\""))))
Theorem:
(defthm cst-underscores-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*\"_\""))))
Theorem:
(defthm cst-hex-digits-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "hex-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hex-digit"))))
Theorem:
(defthm cst-hex-digits-and-underscores-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*hex-digit-or-underscore") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*hex-digit-or-underscore"))))
Theorem:
(defthm cst-hex-digit-or-underscore-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "hex-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hex-digit"))))
Theorem:
(defthm cst-hex-digit-or-underscore-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"_\""))))
Theorem:
(defthm cst-octal-digits-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "octal-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "octal-digit"))))
Theorem:
(defthm cst-octal-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-octal-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-octal-digit-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"2\""))))
Theorem:
(defthm cst-octal-digit-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"3\""))))
Theorem:
(defthm cst-octal-digit-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"4\""))))
Theorem:
(defthm cst-octal-digit-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"5\""))))
Theorem:
(defthm cst-octal-digit-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"6\""))))
Theorem:
(defthm cst-octal-digit-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"7\""))))
Theorem:
(defthm cst-octal-digits-and-underscores-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*octal-digit-or-underscore") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*octal-digit-or-underscore"))))
Theorem:
(defthm cst-octal-digit-or-underscore-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "octal-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "octal-digit"))))
Theorem:
(defthm cst-octal-digit-or-underscore-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"_\""))))
Theorem:
(defthm cst-binary-digits-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "binary-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "binary-digit"))))
Theorem:
(defthm cst-binary-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-binary-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-binary-digits-and-underscores-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*binary-digit-or-underscore") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*binary-digit-or-underscore"))))
Theorem:
(defthm cst-binary-digit-or-underscore-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "binary-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "binary-digit"))))
Theorem:
(defthm cst-binary-digit-or-underscore-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"_\""))))
Theorem:
(defthm cst-floating-point-literal-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "decimal-floating-point-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "decimal-floating-point-literal"))))
Theorem:
(defthm cst-floating-point-literal-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-point-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hexadecimal-floating-point-literal"))))
Theorem:
(defthm cst-exponent-indicator-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"e\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"e\""))))
Theorem:
(defthm cst-sign-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"+\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"+\""))))
Theorem:
(defthm cst-sign-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"-\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"-\""))))
Theorem:
(defthm cst-float-type-suffix-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"f\""))))
Theorem:
(defthm cst-float-type-suffix-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"d\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"d\""))))
Theorem:
(defthm cst-binary-exponent-indicator-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"p\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"p\""))))
Theorem:
(defthm cst-boolean-literal-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"true\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"true\""))))
Theorem:
(defthm cst-boolean-literal-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"false\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"false\""))))
Theorem:
(defthm cst-single-character-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "input-character"))))
Theorem:
(defthm cst-string-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "input-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "input-character"))))
Theorem:
(defthm cst-string-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\b\""))))
Theorem:
(defthm cst-escape-sequence-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\t\""))))
Theorem:
(defthm cst-escape-sequence-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\n\""))))
Theorem:
(defthm cst-escape-sequence-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\f\""))))
Theorem:
(defthm cst-escape-sequence-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\r\""))))
Theorem:
(defthm cst-escape-sequence-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"\\'\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"\\'\""))))
Theorem:
(defthm cst-escape-sequence-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"\\\\\""))))
Theorem:
(defthm cst-escape-sequence-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "octal-escape") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "octal-escape"))))
Theorem:
(defthm cst-zero-to-three-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"0\""))))
Theorem:
(defthm cst-zero-to-three-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-zero-to-three-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"2\""))))
Theorem:
(defthm cst-null-literal-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"null\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"null\""))))
Theorem:
(defthm cst-separator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"(\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"(\""))))
Theorem:
(defthm cst-separator-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\")\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\")\""))))
Theorem:
(defthm cst-separator-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"{\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"{\""))))
Theorem:
(defthm cst-separator-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"}\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"}\""))))
Theorem:
(defthm cst-separator-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"[\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"[\""))))
Theorem:
(defthm cst-separator-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"]\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"]\""))))
Theorem:
(defthm cst-separator-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-separator-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\",\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\",\""))))
Theorem:
(defthm cst-separator-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "\".\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\".\""))))
Theorem:
(defthm cst-separator-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"...\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"...\""))))
Theorem:
(defthm cst-separator-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"@\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"@\""))))
Theorem:
(defthm cst-separator-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"::\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"::\""))))
Theorem:
(defthm cst-operator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"=\""))))
Theorem:
(defthm cst-operator-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">\""))))
Theorem:
(defthm cst-operator-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<\""))))
Theorem:
(defthm cst-operator-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"!\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"!\""))))
Theorem:
(defthm cst-operator-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"~\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"~\""))))
Theorem:
(defthm cst-operator-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"?\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"?\""))))
Theorem:
(defthm cst-operator-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\":\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\":\""))))
Theorem:
(defthm cst-operator-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"->\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"->\""))))
Theorem:
(defthm cst-operator-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"==\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"==\""))))
Theorem:
(defthm cst-operator-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">=\""))))
Theorem:
(defthm cst-operator-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<=\""))))
Theorem:
(defthm cst-operator-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"!=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"!=\""))))
Theorem:
(defthm cst-operator-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"&&\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"&&\""))))
Theorem:
(defthm cst-operator-conc14-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"||\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"||\""))))
Theorem:
(defthm cst-operator-conc15-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"++\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"++\""))))
Theorem:
(defthm cst-operator-conc16-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"--\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"--\""))))
Theorem:
(defthm cst-operator-conc17-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"+\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"+\""))))
Theorem:
(defthm cst-operator-conc18-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"-\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"-\""))))
Theorem:
(defthm cst-operator-conc19-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"*\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"*\""))))
Theorem:
(defthm cst-operator-conc20-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"/\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"/\""))))
Theorem:
(defthm cst-operator-conc21-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"&\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"&\""))))
Theorem:
(defthm cst-operator-conc22-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"|\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"|\""))))
Theorem:
(defthm cst-operator-conc23-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"^\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"^\""))))
Theorem:
(defthm cst-operator-conc24-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"%\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"%\""))))
Theorem:
(defthm cst-operator-conc25-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<<\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<<\""))))
Theorem:
(defthm cst-operator-conc26-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>\""))))
Theorem:
(defthm cst-operator-conc27-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>>\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>>\""))))
Theorem:
(defthm cst-operator-conc28-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"+=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"+=\""))))
Theorem:
(defthm cst-operator-conc29-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"-=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"-=\""))))
Theorem:
(defthm cst-operator-conc30-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"*=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"*=\""))))
Theorem:
(defthm cst-operator-conc31-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"/=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"/=\""))))
Theorem:
(defthm cst-operator-conc32-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"&=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"&=\""))))
Theorem:
(defthm cst-operator-conc33-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"|=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"|=\""))))
Theorem:
(defthm cst-operator-conc34-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"^=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"^=\""))))
Theorem:
(defthm cst-operator-conc35-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"%=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"%=\""))))
Theorem:
(defthm cst-operator-conc36-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<<=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<<=\""))))
Theorem:
(defthm cst-operator-conc37-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>=\""))))
Theorem:
(defthm cst-operator-conc38-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>>=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>>=\""))))
Theorem:
(defthm cst-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "primitive-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "primitive-type"))))
Theorem:
(defthm cst-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "reference-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "reference-type"))))
Theorem:
(defthm cst-numeric-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "integral-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "integral-type"))))
Theorem:
(defthm cst-numeric-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "floating-point-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "floating-point-type"))))
Theorem:
(defthm cst-integral-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"byte\""))))
Theorem:
(defthm cst-integral-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"short\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"short\""))))
Theorem:
(defthm cst-integral-type-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"int\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"int\""))))
Theorem:
(defthm cst-integral-type-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"long\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"long\""))))
Theorem:
(defthm cst-integral-type-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"char\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"char\""))))
Theorem:
(defthm cst-floating-point-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"float\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"float\""))))
Theorem:
(defthm cst-floating-point-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"double\""))))
Theorem:
(defthm cst-reference-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-or-interface-type"))))
Theorem:
(defthm cst-reference-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-variable") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-variable"))))
Theorem:
(defthm cst-reference-type-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "array-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "array-type"))))
Theorem:
(defthm cst-class-or-interface-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-type"))))
Theorem:
(defthm cst-class-or-interface-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-type"))))
Theorem:
(defthm cst-interface-type-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-type"))))
Theorem:
(defthm cst-dims-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*( *annotation \"[\" \"]\" )") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*( *annotation \"[\" \"]\" )"))))
Theorem:
(defthm cst-type-parameter-modifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-type-argument-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "reference-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "reference-type"))))
Theorem:
(defthm cst-type-argument-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "wildcard") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "wildcard"))))
Theorem:
(defthm cst-module-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-package-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-type-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-identifier"))))
Theorem:
(defthm cst-package-or-type-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-expression-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-method-name-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "unqualified-method-identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unqualified-method-identifier"))))
Theorem:
(defthm cst-ambiguous-name-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-compilation-unit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "ordinary-compilation-unit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "ordinary-compilation-unit"))))
Theorem:
(defthm cst-compilation-unit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "modular-compilation-unit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "modular-compilation-unit"))))
Theorem:
(defthm cst-package-modifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-import-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "single-type-import-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "single-type-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-import-on-demand-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-import-on-demand-declaration"))))
Theorem:
(defthm cst-import-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "single-static-import-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "single-static-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "static-import-on-demand-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "static-import-on-demand-declaration"))))
Theorem:
(defthm cst-type-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-declaration"))))
Theorem:
(defthm cst-type-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-declaration"))))
Theorem:
(defthm cst-type-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-requires-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"transitive\""))))
Theorem:
(defthm cst-requires-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-class-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "normal-class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "normal-class-declaration"))))
Theorem:
(defthm cst-class-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "enum-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enum-declaration"))))
Theorem:
(defthm cst-class-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-class-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-class-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-class-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-class-modifier-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-class-modifier-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-class-modifier-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-class-modifier-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"strictfp\""))))
Theorem:
(defthm cst-class-body-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-member-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-member-declaration"))))
Theorem:
(defthm cst-class-body-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "instance-initializer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "instance-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "static-initializer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "static-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "constructor-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "constructor-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "field-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "field-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "method-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "method-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-variable-initializer-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression"))))
Theorem:
(defthm cst-variable-initializer-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "array-initializer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "array-initializer"))))
Theorem:
(defthm cst-unann-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-primitive-type"))))
Theorem:
(defthm cst-unann-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-reference-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-reference-type"))))
Theorem:
(defthm cst-unann-primitive-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "numeric-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "numeric-type"))))
Theorem:
(defthm cst-unann-primitive-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"boolean\""))))
Theorem:
(defthm cst-unann-reference-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-class-or-interface-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-class-or-interface-type"))))
Theorem:
(defthm cst-unann-reference-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-type-variable") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-type-variable"))))
Theorem:
(defthm cst-unann-reference-type-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-array-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-array-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-class-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-class-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-interface-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-interface-type"))))
Theorem:
(defthm cst-unann-interface-type-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-class-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-class-type"))))
Theorem:
(defthm cst-unann-type-variable-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-identifier"))))
Theorem:
(defthm cst-field-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-field-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-field-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-field-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-field-modifier-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-field-modifier-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-field-modifier-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"transient\""))))
Theorem:
(defthm cst-field-modifier-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"volatile\""))))
Theorem:
(defthm cst-formal-parameter-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "variable-arity-parameter"))))
Theorem:
(defthm cst-variable-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-variable-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-method-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-method-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-method-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-method-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-method-modifier-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-method-modifier-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-method-modifier-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-method-modifier-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"synchronized\""))))
Theorem:
(defthm cst-method-modifier-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"native\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"native\""))))
Theorem:
(defthm cst-method-modifier-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"strictfp\""))))
Theorem:
(defthm cst-result-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-type"))))
Theorem:
(defthm cst-result-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"void\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"void\""))))
Theorem:
(defthm cst-exception-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-type"))))
Theorem:
(defthm cst-exception-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-variable") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-variable"))))
Theorem:
(defthm cst-method-body-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "block") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block"))))
Theorem:
(defthm cst-method-body-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-instance-initializer-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "block") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block"))))
Theorem:
(defthm cst-simple-type-name-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-identifier"))))
Theorem:
(defthm cst-constructor-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-constructor-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-constructor-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-constructor-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-enum-constant-modifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-interface-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "normal-interface-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "normal-interface-declaration"))))
Theorem:
(defthm cst-interface-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation-type-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation-type-declaration"))))
Theorem:
(defthm cst-interface-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-interface-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-interface-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"protected\""))))
Theorem:
(defthm cst-interface-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-interface-modifier-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-interface-modifier-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-interface-modifier-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"strictfp\""))))
Theorem:
(defthm cst-interface-member-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "constant-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "constant-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-method-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-method-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-constant-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-constant-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-constant-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-constant-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"final\""))))
Theorem:
(defthm cst-interface-method-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-interface-method-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-interface-method-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"private\""))))
Theorem:
(defthm cst-interface-method-modifier-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-interface-method-modifier-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"default\""))))
Theorem:
(defthm cst-interface-method-modifier-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-interface-method-modifier-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"strictfp\""))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation-type-element-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation-type-element-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "constant-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "constant-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "interface-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "interface-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"public\""))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"abstract\""))))
Theorem:
(defthm cst-annotation-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "normal-annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "normal-annotation"))))
Theorem:
(defthm cst-annotation-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "marker-annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "marker-annotation"))))
Theorem:
(defthm cst-annotation-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "single-element-annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "single-element-annotation"))))
Theorem:
(defthm cst-element-value-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "conditional-expression"))))
Theorem:
(defthm cst-element-value-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "element-value-array-initializer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "element-value-array-initializer"))))
Theorem:
(defthm cst-element-value-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "annotation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "annotation"))))
Theorem:
(defthm cst-block-statements-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*block-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*block-statement"))))
Theorem:
(defthm cst-block-statement-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "local-variable-declaration-statement"))))
Theorem:
(defthm cst-block-statement-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-declaration"))))
Theorem:
(defthm cst-block-statement-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "statement"))))
Theorem:
(defthm cst-local-variable-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-type"))))
Theorem:
(defthm cst-local-variable-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"var\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"var\""))))
Theorem:
(defthm cst-statement-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "labeled-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "labeled-statement"))))
Theorem:
(defthm cst-statement-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "if-then-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "if-then-statement"))))
Theorem:
(defthm cst-statement-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "if-then-else-statement"))))
Theorem:
(defthm cst-statement-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "while-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "while-statement"))))
Theorem:
(defthm cst-statement-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "for-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "for-statement"))))
Theorem:
(defthm cst-statement-no-short-if-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-no-short-if-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "labeled-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "labeled-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "if-then-else-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "while-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "while-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "for-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "for-statement-no-short-if"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "block") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "empty-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "empty-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "assert-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "assert-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "switch-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "switch-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "do-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "do-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "break-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "break-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "continue-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "continue-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "return-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "return-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "synchronized-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "synchronized-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "throw-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "throw-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "try-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "try-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "yield-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "yield-statement"))))
Theorem:
(defthm cst-empty-statement-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "\";\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\";\""))))
Theorem:
(defthm cst-statement-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "assignment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "assignment"))))
Theorem:
(defthm cst-statement-expression-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "pre-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "pre-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "post-increment-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "post-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "post-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "method-invocation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "method-invocation"))))
Theorem:
(defthm cst-statement-expression-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-instance-creation-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-instance-creation-expression"))))
Theorem:
(defthm cst-switch-label-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"default\""))))
Theorem:
(defthm cst-case-constant-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "conditional-expression"))))
Theorem:
(defthm cst-for-statement-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-for-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-for-statement"))))
Theorem:
(defthm cst-for-statement-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enhanced-for-statement"))))
Theorem:
(defthm cst-for-statement-no-short-if-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-for-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-statement-no-short-if-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement-no-short-if") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enhanced-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-init-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "statement-expression-list") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "statement-expression-list"))))
Theorem:
(defthm cst-for-init-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "local-variable-declaration"))))
Theorem:
(defthm cst-for-update-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "statement-expression-list") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "statement-expression-list"))))
Theorem:
(defthm cst-try-statement-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "try-with-resources-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "try-with-resources-statement"))))
Theorem:
(defthm cst-catches-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*catch-clause") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*catch-clause"))))
Theorem:
(defthm cst-resource-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "variable-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "variable-access"))))
Theorem:
(defthm cst-variable-access-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression-name") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression-name"))))
Theorem:
(defthm cst-variable-access-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "field-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "field-access"))))
Theorem:
(defthm cst-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "lambda-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "lambda-expression"))))
Theorem:
(defthm cst-expression-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "assignment-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "assignment-expression"))))
Theorem:
(defthm cst-primary-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "primary-no-new-array"))))
Theorem:
(defthm cst-primary-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "array-creation-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "array-creation-expression"))))
Theorem:
(defthm cst-primary-no-new-array-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "literal"))))
Theorem:
(defthm cst-primary-no-new-array-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-literal"))))
Theorem:
(defthm cst-primary-no-new-array-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"this\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"this\""))))
Theorem:
(defthm cst-primary-no-new-array-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "class-instance-creation-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "class-instance-creation-expression"))))
Theorem:
(defthm cst-primary-no-new-array-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "field-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "field-access"))))
Theorem:
(defthm cst-primary-no-new-array-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "array-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "array-access"))))
Theorem:
(defthm cst-primary-no-new-array-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "method-invocation") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "method-invocation"))))
Theorem:
(defthm cst-primary-no-new-array-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "method-reference") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "method-reference"))))
Theorem:
(defthm cst-class-instance-creation-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unqualified-class-instance-creation-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unqualified-class-instance-creation-expression"))))
Theorem:
(defthm cst-type-arguments-or-diamond-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-arguments") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-arguments"))))
Theorem:
(defthm cst-type-arguments-or-diamond-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<>\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<>\""))))
Theorem:
(defthm cst-dim-exprs-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*dim-expr") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*dim-expr"))))
Theorem:
(defthm cst-postfix-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "primary") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "primary"))))
Theorem:
(defthm cst-postfix-expression-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression-name") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression-name"))))
Theorem:
(defthm cst-postfix-expression-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "post-increment-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "post-increment-expression"))))
Theorem:
(defthm cst-postfix-expression-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "post-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "pre-increment-expression"))))
Theorem:
(defthm cst-unary-expression-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "pre-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "unary-expression-not-plus-minus") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unary-expression-not-plus-minus"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "postfix-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "postfix-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "cast-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "cast-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "switch-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "switch-expression"))))
Theorem:
(defthm cst-multiplicative-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unary-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unary-expression"))))
Theorem:
(defthm cst-additive-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "multiplicative-expression"))))
Theorem:
(defthm cst-shift-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "additive-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "additive-expression"))))
Theorem:
(defthm cst-relational-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "shift-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "shift-expression"))))
Theorem:
(defthm cst-equality-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "relational-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "relational-expression"))))
Theorem:
(defthm cst-and-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "equality-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "equality-expression"))))
Theorem:
(defthm cst-exclusive-or-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "and-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "and-expression"))))
Theorem:
(defthm cst-inclusive-or-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "exclusive-or-expression"))))
Theorem:
(defthm cst-conditional-and-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "inclusive-or-expression"))))
Theorem:
(defthm cst-conditional-or-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "conditional-and-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "conditional-and-expression"))))
Theorem:
(defthm cst-conditional-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "conditional-or-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "conditional-or-expression"))))
Theorem:
(defthm cst-assignment-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "conditional-expression"))))
Theorem:
(defthm cst-assignment-expression-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "assignment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "assignment"))))
Theorem:
(defthm cst-left-hand-side-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression-name") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression-name"))))
Theorem:
(defthm cst-left-hand-side-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "field-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "field-access"))))
Theorem:
(defthm cst-left-hand-side-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "array-access") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "array-access"))))
Theorem:
(defthm cst-assignment-operator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"=\""))))
Theorem:
(defthm cst-assignment-operator-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"*=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"*=\""))))
Theorem:
(defthm cst-assignment-operator-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"/=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"/=\""))))
Theorem:
(defthm cst-assignment-operator-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"%=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"%=\""))))
Theorem:
(defthm cst-assignment-operator-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"+=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"+=\""))))
Theorem:
(defthm cst-assignment-operator-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"-=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"-=\""))))
Theorem:
(defthm cst-assignment-operator-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"<<=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"<<=\""))))
Theorem:
(defthm cst-assignment-operator-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>=\""))))
Theorem:
(defthm cst-assignment-operator-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "\">>>=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\">>>=\""))))
Theorem:
(defthm cst-assignment-operator-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"&=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"&=\""))))
Theorem:
(defthm cst-assignment-operator-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"^=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"^=\""))))
Theorem:
(defthm cst-assignment-operator-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"|=\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"|=\""))))
Theorem:
(defthm cst-lambda-parameters-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier"))))
Theorem:
(defthm cst-lambda-parameter-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "variable-arity-parameter"))))
Theorem:
(defthm cst-lambda-parameter-type-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "unann-type") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "unann-type"))))
Theorem:
(defthm cst-lambda-parameter-type-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"var\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"var\""))))
Theorem:
(defthm cst-lambda-body-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression"))))
Theorem:
(defthm cst-lambda-body-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "block") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block"))))
Theorem:
(defthm cst-constant-expression-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "expression"))))
Theorem:
(defthm cst-unicode-input-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unicode-escape") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unicode-escape"))))
Theorem:
(defthm cst-unicode-input-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "raw-input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "raw-input-character"))))
Theorem:
(defthm cst-hex-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-hex-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-hex-digit-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"2\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"2\""))))
Theorem:
(defthm cst-hex-digit-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"3\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"3\""))))
Theorem:
(defthm cst-hex-digit-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"4\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"4\""))))
Theorem:
(defthm cst-hex-digit-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"5\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"5\""))))
Theorem:
(defthm cst-hex-digit-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"6\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"6\""))))
Theorem:
(defthm cst-hex-digit-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"7\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"7\""))))
Theorem:
(defthm cst-hex-digit-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"8\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"8\""))))
Theorem:
(defthm cst-hex-digit-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"9\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"9\""))))
Theorem:
(defthm cst-hex-digit-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"a\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"a\""))))
Theorem:
(defthm cst-hex-digit-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"b\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"b\""))))
Theorem:
(defthm cst-hex-digit-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"c\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"c\""))))
Theorem:
(defthm cst-hex-digit-conc14-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"d\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"d\""))))
Theorem:
(defthm cst-hex-digit-conc15-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"e\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"e\""))))
Theorem:
(defthm cst-hex-digit-conc16-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"f\""))))
Theorem:
(defthm cst-raw-input-character-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x0-FFFF") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x0-FFFF"))))
Theorem:
(defthm cst-line-terminator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d10") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d10"))))
Theorem:
(defthm cst-line-terminator-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d13") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d13"))))
Theorem:
(defthm cst-line-terminator-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d13.10") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d13.10"))))
Theorem:
(defthm cst-input-character-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "unicode-input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unicode-input-character"))))
Theorem:
(defthm cst-input-element-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "white-space") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "white-space"))))
Theorem:
(defthm cst-input-element-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "comment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "comment"))))
Theorem:
(defthm cst-input-element-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "token") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "token"))))
Theorem:
(defthm cst-token-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-token-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "keyword") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "keyword"))))
Theorem:
(defthm cst-token-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "literal"))))
Theorem:
(defthm cst-token-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "separator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "separator"))))
Theorem:
(defthm cst-token-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "operator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "operator"))))
Theorem:
(defthm cst-sub-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d26") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d26"))))
Theorem:
(defthm cst-white-space-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d32") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d32"))))
Theorem:
(defthm cst-white-space-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d9") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d9"))))
Theorem:
(defthm cst-white-space-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%d12") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%d12"))))
Theorem:
(defthm cst-white-space-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-terminator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-terminator"))))
Theorem:
(defthm cst-comment-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "traditional-comment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "traditional-comment"))))
Theorem:
(defthm cst-comment-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "end-of-line-comment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "end-of-line-comment"))))
Theorem:
(defthm cst-comment-tail-star-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"/\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"/\""))))
Theorem:
(defthm cst-not-star-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "input-character"))))
Theorem:
(defthm cst-not-star-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-terminator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-terminator"))))
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "input-character"))))
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-terminator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-terminator"))))
Theorem:
(defthm cst-identifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier-chars") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier-chars"))))
Theorem:
(defthm cst-java-letter-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "raw-input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "raw-input-character"))))
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "raw-input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "raw-input-character"))))
Theorem:
(defthm cst-type-identifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-keyword-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-keyword-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"assert\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"assert\""))))
Theorem:
(defthm cst-keyword-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"boolean\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"boolean\""))))
Theorem:
(defthm cst-keyword-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"break\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"break\""))))
Theorem:
(defthm cst-keyword-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"byte\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"byte\""))))
Theorem:
(defthm cst-keyword-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"case\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"case\""))))
Theorem:
(defthm cst-keyword-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"catch\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"catch\""))))
Theorem:
(defthm cst-keyword-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"char\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"char\""))))
Theorem:
(defthm cst-keyword-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"class\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"class\""))))
Theorem:
(defthm cst-keyword-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"const\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"const\""))))
Theorem:
(defthm cst-keyword-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"continue\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"continue\""))))
Theorem:
(defthm cst-keyword-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"default\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"default\""))))
Theorem:
(defthm cst-keyword-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"do\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"do\""))))
Theorem:
(defthm cst-keyword-conc14-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"double\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"double\""))))
Theorem:
(defthm cst-keyword-conc15-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"else\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"else\""))))
Theorem:
(defthm cst-keyword-conc16-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"enum\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"enum\""))))
Theorem:
(defthm cst-keyword-conc17-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"extends\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"extends\""))))
Theorem:
(defthm cst-keyword-conc18-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-keyword-conc19-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"finally\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"finally\""))))
Theorem:
(defthm cst-keyword-conc20-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"float\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"float\""))))
Theorem:
(defthm cst-keyword-conc21-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"for\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"for\""))))
Theorem:
(defthm cst-keyword-conc22-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"if\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"if\""))))
Theorem:
(defthm cst-keyword-conc23-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"goto\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"goto\""))))
Theorem:
(defthm cst-keyword-conc24-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"implements\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"implements\""))))
Theorem:
(defthm cst-keyword-conc25-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"import\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"import\""))))
Theorem:
(defthm cst-keyword-conc26-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"instanceof\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"instanceof\""))))
Theorem:
(defthm cst-keyword-conc27-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"int\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"int\""))))
Theorem:
(defthm cst-keyword-conc28-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"interface\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"interface\""))))
Theorem:
(defthm cst-keyword-conc29-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"long\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"long\""))))
Theorem:
(defthm cst-keyword-conc30-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"native\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"native\""))))
Theorem:
(defthm cst-keyword-conc31-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"new\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"new\""))))
Theorem:
(defthm cst-keyword-conc32-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"package\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"package\""))))
Theorem:
(defthm cst-keyword-conc33-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-keyword-conc34-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-keyword-conc35-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-keyword-conc36-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"return\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"return\""))))
Theorem:
(defthm cst-keyword-conc37-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"short\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"short\""))))
Theorem:
(defthm cst-keyword-conc38-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-keyword-conc39-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"strictfp\""))))
Theorem:
(defthm cst-keyword-conc40-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"super\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"super\""))))
Theorem:
(defthm cst-keyword-conc41-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"switch\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"switch\""))))
Theorem:
(defthm cst-keyword-conc42-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"synchronized\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"synchronized\""))))
Theorem:
(defthm cst-keyword-conc43-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"this\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"this\""))))
Theorem:
(defthm cst-keyword-conc44-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"throw\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"throw\""))))
Theorem:
(defthm cst-keyword-conc45-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"throws\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"throws\""))))
Theorem:
(defthm cst-keyword-conc46-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"transient\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"transient\""))))
Theorem:
(defthm cst-keyword-conc47-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"try\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"try\""))))
Theorem:
(defthm cst-keyword-conc48-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"void\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"void\""))))
Theorem:
(defthm cst-keyword-conc49-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"volatile\""))))
Theorem:
(defthm cst-keyword-conc50-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"while\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"while\""))))
Theorem:
(defthm cst-keyword-conc51-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"_\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"_\""))))
Theorem:
(defthm cst-literal-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "integer-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "integer-literal"))))
Theorem:
(defthm cst-literal-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "floating-point-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "floating-point-literal"))))
Theorem:
(defthm cst-literal-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "boolean-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "boolean-literal"))))
Theorem:
(defthm cst-literal-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "character-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "character-literal"))))
Theorem:
(defthm cst-literal-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "string-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "string-literal"))))
Theorem:
(defthm cst-literal-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "null-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "null-literal"))))
Theorem:
(defthm cst-integer-literal-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "decimal-integer-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "decimal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "hex-integer-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hex-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "octal-integer-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "octal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "binary-integer-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "binary-integer-literal"))))
Theorem:
(defthm cst-integer-type-suffix-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"l\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"l\""))))
Theorem:
(defthm cst-decimal-numeral-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-non-zero-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-non-zero-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"2\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"2\""))))
Theorem:
(defthm cst-non-zero-digit-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"3\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"3\""))))
Theorem:
(defthm cst-non-zero-digit-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"4\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"4\""))))
Theorem:
(defthm cst-non-zero-digit-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"5\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"5\""))))
Theorem:
(defthm cst-non-zero-digit-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"6\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"6\""))))
Theorem:
(defthm cst-non-zero-digit-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"7\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"7\""))))
Theorem:
(defthm cst-non-zero-digit-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"8\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"8\""))))
Theorem:
(defthm cst-non-zero-digit-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"9\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"9\""))))
Theorem:
(defthm cst-digits-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "non-zero-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "non-zero-digit"))))
Theorem:
(defthm cst-digit-or-underscore-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-digit-or-underscore-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"_\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"_\""))))
Theorem:
(defthm cst-hex-digits-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "hex-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hex-digit"))))
Theorem:
(defthm cst-hex-digit-or-underscore-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "hex-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hex-digit"))))
Theorem:
(defthm cst-hex-digit-or-underscore-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"_\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"_\""))))
Theorem:
(defthm cst-octal-digits-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "octal-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "octal-digit"))))
Theorem:
(defthm cst-octal-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-octal-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-octal-digit-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"2\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"2\""))))
Theorem:
(defthm cst-octal-digit-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"3\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"3\""))))
Theorem:
(defthm cst-octal-digit-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"4\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"4\""))))
Theorem:
(defthm cst-octal-digit-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"5\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"5\""))))
Theorem:
(defthm cst-octal-digit-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"6\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"6\""))))
Theorem:
(defthm cst-octal-digit-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"7\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"7\""))))
Theorem:
(defthm cst-octal-digit-or-underscore-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "octal-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "octal-digit"))))
Theorem:
(defthm cst-octal-digit-or-underscore-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"_\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"_\""))))
Theorem:
(defthm cst-binary-digits-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "binary-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "binary-digit"))))
Theorem:
(defthm cst-binary-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-binary-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-binary-digit-or-underscore-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "binary-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "binary-digit"))))
Theorem:
(defthm cst-binary-digit-or-underscore-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"_\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"_\""))))
Theorem:
(defthm cst-floating-point-literal-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "decimal-floating-point-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "decimal-floating-point-literal"))))
Theorem:
(defthm cst-floating-point-literal-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "hexadecimal-floating-point-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hexadecimal-floating-point-literal"))))
Theorem:
(defthm cst-exponent-indicator-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"e\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"e\""))))
Theorem:
(defthm cst-sign-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+\""))))
Theorem:
(defthm cst-sign-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-\""))))
Theorem:
(defthm cst-float-type-suffix-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"f\""))))
Theorem:
(defthm cst-float-type-suffix-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"d\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"d\""))))
Theorem:
(defthm cst-binary-exponent-indicator-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"p\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"p\""))))
Theorem:
(defthm cst-boolean-literal-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"true\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"true\""))))
Theorem:
(defthm cst-boolean-literal-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"false\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"false\""))))
Theorem:
(defthm cst-single-character-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "input-character"))))
Theorem:
(defthm cst-string-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "input-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "input-character"))))
Theorem:
(defthm cst-string-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\b\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\b\""))))
Theorem:
(defthm cst-escape-sequence-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\t\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\t\""))))
Theorem:
(defthm cst-escape-sequence-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\n\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\n\""))))
Theorem:
(defthm cst-escape-sequence-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\f\""))))
Theorem:
(defthm cst-escape-sequence-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\r\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\r\""))))
Theorem:
(defthm cst-escape-sequence-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"\\'\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"\\'\""))))
Theorem:
(defthm cst-escape-sequence-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"\\\\\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"\\\\\""))))
Theorem:
(defthm cst-escape-sequence-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "octal-escape") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "octal-escape"))))
Theorem:
(defthm cst-zero-to-three-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"0\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"0\""))))
Theorem:
(defthm cst-zero-to-three-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-zero-to-three-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"2\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"2\""))))
Theorem:
(defthm cst-null-literal-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"null\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"null\""))))
Theorem:
(defthm cst-separator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"(\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"(\""))))
Theorem:
(defthm cst-separator-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\")\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\")\""))))
Theorem:
(defthm cst-separator-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"{\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"{\""))))
Theorem:
(defthm cst-separator-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"}\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"}\""))))
Theorem:
(defthm cst-separator-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"[\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"[\""))))
Theorem:
(defthm cst-separator-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"]\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"]\""))))
Theorem:
(defthm cst-separator-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-separator-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\",\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\",\""))))
Theorem:
(defthm cst-separator-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "\".\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\".\""))))
Theorem:
(defthm cst-separator-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"...\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"...\""))))
Theorem:
(defthm cst-separator-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"@\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"@\""))))
Theorem:
(defthm cst-separator-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"::\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"::\""))))
Theorem:
(defthm cst-operator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"=\""))))
Theorem:
(defthm cst-operator-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">\""))))
Theorem:
(defthm cst-operator-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<\""))))
Theorem:
(defthm cst-operator-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"!\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"!\""))))
Theorem:
(defthm cst-operator-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"~\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"~\""))))
Theorem:
(defthm cst-operator-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"?\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"?\""))))
Theorem:
(defthm cst-operator-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\":\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\":\""))))
Theorem:
(defthm cst-operator-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"->\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"->\""))))
Theorem:
(defthm cst-operator-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"==\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"==\""))))
Theorem:
(defthm cst-operator-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">=\""))))
Theorem:
(defthm cst-operator-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<=\""))))
Theorem:
(defthm cst-operator-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"!=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"!=\""))))
Theorem:
(defthm cst-operator-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"&&\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"&&\""))))
Theorem:
(defthm cst-operator-conc14-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"||\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"||\""))))
Theorem:
(defthm cst-operator-conc15-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"++\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"++\""))))
Theorem:
(defthm cst-operator-conc16-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"--\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"--\""))))
Theorem:
(defthm cst-operator-conc17-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+\""))))
Theorem:
(defthm cst-operator-conc18-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-\""))))
Theorem:
(defthm cst-operator-conc19-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"*\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"*\""))))
Theorem:
(defthm cst-operator-conc20-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"/\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"/\""))))
Theorem:
(defthm cst-operator-conc21-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"&\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"&\""))))
Theorem:
(defthm cst-operator-conc22-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"|\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"|\""))))
Theorem:
(defthm cst-operator-conc23-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"^\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"^\""))))
Theorem:
(defthm cst-operator-conc24-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%\""))))
Theorem:
(defthm cst-operator-conc25-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<<\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<<\""))))
Theorem:
(defthm cst-operator-conc26-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>\""))))
Theorem:
(defthm cst-operator-conc27-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>>\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>>\""))))
Theorem:
(defthm cst-operator-conc28-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+=\""))))
Theorem:
(defthm cst-operator-conc29-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-=\""))))
Theorem:
(defthm cst-operator-conc30-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"*=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"*=\""))))
Theorem:
(defthm cst-operator-conc31-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"/=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"/=\""))))
Theorem:
(defthm cst-operator-conc32-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"&=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"&=\""))))
Theorem:
(defthm cst-operator-conc33-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"|=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"|=\""))))
Theorem:
(defthm cst-operator-conc34-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"^=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"^=\""))))
Theorem:
(defthm cst-operator-conc35-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%=\""))))
Theorem:
(defthm cst-operator-conc36-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<<=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<<=\""))))
Theorem:
(defthm cst-operator-conc37-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>=\""))))
Theorem:
(defthm cst-operator-conc38-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>>=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>>=\""))))
Theorem:
(defthm cst-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "primitive-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "primitive-type"))))
Theorem:
(defthm cst-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "reference-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "reference-type"))))
Theorem:
(defthm cst-numeric-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "integral-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "integral-type"))))
Theorem:
(defthm cst-numeric-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "floating-point-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "floating-point-type"))))
Theorem:
(defthm cst-integral-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"byte\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"byte\""))))
Theorem:
(defthm cst-integral-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"short\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"short\""))))
Theorem:
(defthm cst-integral-type-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"int\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"int\""))))
Theorem:
(defthm cst-integral-type-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"long\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"long\""))))
Theorem:
(defthm cst-integral-type-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"char\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"char\""))))
Theorem:
(defthm cst-floating-point-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"float\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"float\""))))
Theorem:
(defthm cst-floating-point-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"double\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"double\""))))
Theorem:
(defthm cst-reference-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-or-interface-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-or-interface-type"))))
Theorem:
(defthm cst-reference-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-variable") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-variable"))))
Theorem:
(defthm cst-reference-type-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "array-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "array-type"))))
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-type"))))
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-type"))))
Theorem:
(defthm cst-interface-type-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-type"))))
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-type-argument-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "reference-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "reference-type"))))
Theorem:
(defthm cst-type-argument-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "wildcard") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "wildcard"))))
Theorem:
(defthm cst-module-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-package-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-type-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-identifier"))))
Theorem:
(defthm cst-package-or-type-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-expression-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-method-name-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "unqualified-method-identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unqualified-method-identifier"))))
Theorem:
(defthm cst-ambiguous-name-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-compilation-unit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "ordinary-compilation-unit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "ordinary-compilation-unit"))))
Theorem:
(defthm cst-compilation-unit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "modular-compilation-unit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "modular-compilation-unit"))))
Theorem:
(defthm cst-package-modifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-import-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "single-type-import-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "single-type-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-import-on-demand-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-import-on-demand-declaration"))))
Theorem:
(defthm cst-import-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "single-static-import-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "single-static-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "static-import-on-demand-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "static-import-on-demand-declaration"))))
Theorem:
(defthm cst-type-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-declaration"))))
Theorem:
(defthm cst-type-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-declaration"))))
Theorem:
(defthm cst-type-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-requires-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"transitive\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"transitive\""))))
Theorem:
(defthm cst-requires-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-class-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "normal-class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "normal-class-declaration"))))
Theorem:
(defthm cst-class-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "enum-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enum-declaration"))))
Theorem:
(defthm cst-class-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-class-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-class-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-class-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-class-modifier-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-class-modifier-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-class-modifier-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-class-modifier-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"strictfp\""))))
Theorem:
(defthm cst-class-body-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-member-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-member-declaration"))))
Theorem:
(defthm cst-class-body-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "instance-initializer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "instance-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "static-initializer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "static-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "constructor-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "constructor-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "field-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "field-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "method-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "method-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-declaration"))))
Theorem:
(defthm cst-class-member-declaration-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-variable-initializer-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression"))))
Theorem:
(defthm cst-variable-initializer-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "array-initializer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "array-initializer"))))
Theorem:
(defthm cst-unann-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-primitive-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-primitive-type"))))
Theorem:
(defthm cst-unann-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-reference-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-reference-type"))))
Theorem:
(defthm cst-unann-primitive-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "numeric-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "numeric-type"))))
Theorem:
(defthm cst-unann-primitive-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"boolean\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"boolean\""))))
Theorem:
(defthm cst-unann-reference-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-class-or-interface-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-class-or-interface-type"))))
Theorem:
(defthm cst-unann-reference-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-type-variable") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-type-variable"))))
Theorem:
(defthm cst-unann-reference-type-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-array-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-array-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-class-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-class-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-interface-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-interface-type"))))
Theorem:
(defthm cst-unann-interface-type-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-class-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-class-type"))))
Theorem:
(defthm cst-unann-type-variable-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-identifier"))))
Theorem:
(defthm cst-field-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-field-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-field-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-field-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-field-modifier-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-field-modifier-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-field-modifier-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"transient\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"transient\""))))
Theorem:
(defthm cst-field-modifier-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"volatile\""))))
Theorem:
(defthm cst-formal-parameter-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "variable-arity-parameter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "variable-arity-parameter"))))
Theorem:
(defthm cst-variable-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-variable-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-method-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-method-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-method-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-method-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-method-modifier-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-method-modifier-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-method-modifier-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-method-modifier-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"synchronized\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"synchronized\""))))
Theorem:
(defthm cst-method-modifier-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"native\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"native\""))))
Theorem:
(defthm cst-method-modifier-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"strictfp\""))))
Theorem:
(defthm cst-result-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-type"))))
Theorem:
(defthm cst-result-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"void\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"void\""))))
Theorem:
(defthm cst-exception-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-type"))))
Theorem:
(defthm cst-exception-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-variable") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-variable"))))
Theorem:
(defthm cst-method-body-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "block") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block"))))
Theorem:
(defthm cst-method-body-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-instance-initializer-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "block") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block"))))
Theorem:
(defthm cst-simple-type-name-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-identifier"))))
Theorem:
(defthm cst-constructor-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-constructor-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-constructor-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-constructor-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-interface-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "normal-interface-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "normal-interface-declaration"))))
Theorem:
(defthm cst-interface-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation-type-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation-type-declaration"))))
Theorem:
(defthm cst-interface-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-interface-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-interface-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"protected\""))))
Theorem:
(defthm cst-interface-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-interface-modifier-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-interface-modifier-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-interface-modifier-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"strictfp\""))))
Theorem:
(defthm cst-interface-member-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "constant-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "constant-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-method-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-method-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-declaration"))))
Theorem:
(defthm cst-interface-member-declaration-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-constant-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-constant-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-constant-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-constant-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"final\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"final\""))))
Theorem:
(defthm cst-interface-method-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-interface-method-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-interface-method-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"private\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"private\""))))
Theorem:
(defthm cst-interface-method-modifier-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-interface-method-modifier-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"default\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"default\""))))
Theorem:
(defthm cst-interface-method-modifier-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-interface-method-modifier-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"strictfp\""))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation-type-element-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation-type-element-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "constant-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "constant-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "interface-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "interface-declaration"))))
Theorem:
(defthm cst-annotation-type-member-declaration-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"public\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"public\""))))
Theorem:
(defthm cst-annotation-type-element-modifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"abstract\""))))
Theorem:
(defthm cst-annotation-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "normal-annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "normal-annotation"))))
Theorem:
(defthm cst-annotation-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "marker-annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "marker-annotation"))))
Theorem:
(defthm cst-annotation-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "single-element-annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "single-element-annotation"))))
Theorem:
(defthm cst-element-value-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "conditional-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "conditional-expression"))))
Theorem:
(defthm cst-element-value-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "element-value-array-initializer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "element-value-array-initializer"))))
Theorem:
(defthm cst-element-value-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "annotation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "annotation"))))
Theorem:
(defthm cst-block-statement-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "local-variable-declaration-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "local-variable-declaration-statement"))))
Theorem:
(defthm cst-block-statement-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-declaration"))))
Theorem:
(defthm cst-block-statement-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "statement"))))
Theorem:
(defthm cst-local-variable-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-type"))))
Theorem:
(defthm cst-local-variable-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"var\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"var\""))))
Theorem:
(defthm cst-statement-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "statement-without-trailing-substatement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "labeled-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "labeled-statement"))))
Theorem:
(defthm cst-statement-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "if-then-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "if-then-statement"))))
Theorem:
(defthm cst-statement-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "if-then-else-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "if-then-else-statement"))))
Theorem:
(defthm cst-statement-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "while-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "while-statement"))))
Theorem:
(defthm cst-statement-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "for-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "for-statement"))))
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "statement-without-trailing-substatement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "labeled-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "labeled-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "if-then-else-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "if-then-else-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "while-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "while-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "for-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "for-statement-no-short-if"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "block") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "empty-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "empty-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "assert-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "assert-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "switch-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "switch-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "do-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "do-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "break-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "break-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "continue-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "continue-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "return-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "return-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "synchronized-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "synchronized-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "throw-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "throw-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "try-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "try-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "yield-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "yield-statement"))))
Theorem:
(defthm cst-empty-statement-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "\";\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\";\""))))
Theorem:
(defthm cst-statement-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "assignment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "assignment"))))
Theorem:
(defthm cst-statement-expression-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "pre-increment-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "pre-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "pre-decrement-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "pre-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "post-increment-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "post-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "post-decrement-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "post-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "method-invocation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "method-invocation"))))
Theorem:
(defthm cst-statement-expression-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-instance-creation-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-instance-creation-expression"))))
Theorem:
(defthm cst-switch-label-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"default\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"default\""))))
Theorem:
(defthm cst-case-constant-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "conditional-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "conditional-expression"))))
Theorem:
(defthm cst-for-statement-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-for-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-for-statement"))))
Theorem:
(defthm cst-for-statement-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "enhanced-for-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enhanced-for-statement"))))
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-for-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "enhanced-for-statement-no-short-if") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enhanced-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-init-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "statement-expression-list") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "statement-expression-list"))))
Theorem:
(defthm cst-for-init-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "local-variable-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "local-variable-declaration"))))
Theorem:
(defthm cst-for-update-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "statement-expression-list") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "statement-expression-list"))))
Theorem:
(defthm cst-try-statement-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "try-with-resources-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "try-with-resources-statement"))))
Theorem:
(defthm cst-resource-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "variable-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "variable-access"))))
Theorem:
(defthm cst-variable-access-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression-name") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression-name"))))
Theorem:
(defthm cst-variable-access-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "field-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "field-access"))))
Theorem:
(defthm cst-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "lambda-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "lambda-expression"))))
Theorem:
(defthm cst-expression-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "assignment-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "assignment-expression"))))
Theorem:
(defthm cst-primary-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "primary-no-new-array") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "primary-no-new-array"))))
Theorem:
(defthm cst-primary-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "array-creation-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "array-creation-expression"))))
Theorem:
(defthm cst-primary-no-new-array-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "literal"))))
Theorem:
(defthm cst-primary-no-new-array-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-literal"))))
Theorem:
(defthm cst-primary-no-new-array-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"this\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"this\""))))
Theorem:
(defthm cst-primary-no-new-array-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "class-instance-creation-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "class-instance-creation-expression"))))
Theorem:
(defthm cst-primary-no-new-array-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "field-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "field-access"))))
Theorem:
(defthm cst-primary-no-new-array-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "array-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "array-access"))))
Theorem:
(defthm cst-primary-no-new-array-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "method-invocation") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "method-invocation"))))
Theorem:
(defthm cst-primary-no-new-array-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "method-reference") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "method-reference"))))
Theorem:
(defthm cst-class-instance-creation-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unqualified-class-instance-creation-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unqualified-class-instance-creation-expression"))))
Theorem:
(defthm cst-type-arguments-or-diamond-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-arguments") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-arguments"))))
Theorem:
(defthm cst-type-arguments-or-diamond-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<>\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<>\""))))
Theorem:
(defthm cst-postfix-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "primary") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "primary"))))
Theorem:
(defthm cst-postfix-expression-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression-name") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression-name"))))
Theorem:
(defthm cst-postfix-expression-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "post-increment-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "post-increment-expression"))))
Theorem:
(defthm cst-postfix-expression-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "post-decrement-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "post-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "pre-increment-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "pre-increment-expression"))))
Theorem:
(defthm cst-unary-expression-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "pre-decrement-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "pre-decrement-expression"))))
Theorem:
(defthm cst-unary-expression-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "unary-expression-not-plus-minus") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unary-expression-not-plus-minus"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "postfix-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "postfix-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "cast-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "cast-expression"))))
Theorem:
(defthm cst-unary-expression-not-plus-minus-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "switch-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "switch-expression"))))
Theorem:
(defthm cst-multiplicative-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unary-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unary-expression"))))
Theorem:
(defthm cst-additive-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "multiplicative-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "multiplicative-expression"))))
Theorem:
(defthm cst-shift-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "additive-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "additive-expression"))))
Theorem:
(defthm cst-relational-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "shift-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "shift-expression"))))
Theorem:
(defthm cst-equality-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "relational-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "relational-expression"))))
Theorem:
(defthm cst-and-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "equality-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "equality-expression"))))
Theorem:
(defthm cst-exclusive-or-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "and-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "and-expression"))))
Theorem:
(defthm cst-inclusive-or-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "exclusive-or-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "exclusive-or-expression"))))
Theorem:
(defthm cst-conditional-and-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "inclusive-or-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "inclusive-or-expression"))))
Theorem:
(defthm cst-conditional-or-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "conditional-and-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "conditional-and-expression"))))
Theorem:
(defthm cst-conditional-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "conditional-or-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "conditional-or-expression"))))
Theorem:
(defthm cst-assignment-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "conditional-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "conditional-expression"))))
Theorem:
(defthm cst-assignment-expression-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "assignment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "assignment"))))
Theorem:
(defthm cst-left-hand-side-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression-name") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression-name"))))
Theorem:
(defthm cst-left-hand-side-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "field-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "field-access"))))
Theorem:
(defthm cst-left-hand-side-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "array-access") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "array-access"))))
Theorem:
(defthm cst-assignment-operator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"=\""))))
Theorem:
(defthm cst-assignment-operator-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"*=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"*=\""))))
Theorem:
(defthm cst-assignment-operator-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"/=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"/=\""))))
Theorem:
(defthm cst-assignment-operator-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%=\""))))
Theorem:
(defthm cst-assignment-operator-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+=\""))))
Theorem:
(defthm cst-assignment-operator-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-=\""))))
Theorem:
(defthm cst-assignment-operator-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<<=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<<=\""))))
Theorem:
(defthm cst-assignment-operator-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>=\""))))
Theorem:
(defthm cst-assignment-operator-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>>=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>>=\""))))
Theorem:
(defthm cst-assignment-operator-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"&=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"&=\""))))
Theorem:
(defthm cst-assignment-operator-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"^=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"^=\""))))
Theorem:
(defthm cst-assignment-operator-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"|=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"|=\""))))
Theorem:
(defthm cst-lambda-parameters-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier"))))
Theorem:
(defthm cst-lambda-parameter-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "variable-arity-parameter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "variable-arity-parameter"))))
Theorem:
(defthm cst-lambda-parameter-type-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "unann-type") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "unann-type"))))
Theorem:
(defthm cst-lambda-parameter-type-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"var\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"var\""))))
Theorem:
(defthm cst-lambda-body-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression"))))
Theorem:
(defthm cst-lambda-body-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "block") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block"))))
Theorem:
(defthm cst-constant-expression-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "expression"))))
Theorem:
(defthm cst-unicode-input-character-conc-equivs (implies (cst-matchp abnf::cst "unicode-input-character") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unicode-escape") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unicode-escape"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "raw-input-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "raw-input-character"))))))
Theorem:
(defthm cst-input-element-conc-equivs (implies (cst-matchp abnf::cst "input-element") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "white-space") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "white-space"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "comment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "comment"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "token") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "token"))))))
Theorem:
(defthm cst-token-conc-equivs (implies (cst-matchp abnf::cst "token") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "identifier"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "keyword") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "keyword"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "separator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "separator"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "operator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "operator"))))))
Theorem:
(defthm cst-comment-conc-equivs (implies (cst-matchp abnf::cst "comment") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "traditional-comment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "traditional-comment"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "end-of-line-comment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "end-of-line-comment"))))))
Theorem:
(defthm cst-not-star-conc-equivs (implies (cst-matchp abnf::cst "not-star") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "line-terminator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "line-terminator"))))))
Theorem:
(defthm cst-not-star-not-slash-conc-equivs (implies (cst-matchp abnf::cst "not-star-not-slash") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "line-terminator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "line-terminator"))))))
Theorem:
(defthm cst-literal-conc-equivs (implies (cst-matchp abnf::cst "literal") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integer-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "floating-point-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "floating-point-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "boolean-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "boolean-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "string-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "string-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "null-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "null-literal"))))))
Theorem:
(defthm cst-integer-literal-conc-equivs (implies (cst-matchp abnf::cst "integer-literal") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-integer-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-integer-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-integer-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hex-integer-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-integer-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "octal-integer-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-integer-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "binary-integer-literal"))))))
Theorem:
(defthm cst-floating-point-literal-conc-equivs (implies (cst-matchp abnf::cst "floating-point-literal") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-point-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-floating-point-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-floating-point-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-floating-point-literal"))))))
Theorem:
(defthm cst-string-character-conc-equivs (implies (cst-matchp abnf::cst "string-character") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence"))))))
Theorem:
(defthm cst-type-conc-equivs (implies (cst-matchp abnf::cst "type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primitive-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primitive-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "reference-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "reference-type"))))))
Theorem:
(defthm cst-numeric-type-conc-equivs (implies (cst-matchp abnf::cst "numeric-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integral-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integral-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "floating-point-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "floating-point-type"))))))
Theorem:
(defthm cst-reference-type-conc-equivs (implies (cst-matchp abnf::cst "reference-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-or-interface-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-or-interface-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-variable") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-variable"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-type"))))))
Theorem:
(defthm cst-class-or-interface-type-conc-equivs (implies (cst-matchp abnf::cst "class-or-interface-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "interface-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "interface-type"))))))
Theorem:
(defthm cst-type-argument-conc-equivs (implies (cst-matchp abnf::cst "type-argument") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "reference-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "reference-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "wildcard") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "wildcard"))))))
Theorem:
(defthm cst-compilation-unit-conc-equivs (implies (cst-matchp abnf::cst "compilation-unit") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "ordinary-compilation-unit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "ordinary-compilation-unit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "modular-compilation-unit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "modular-compilation-unit"))))))
Theorem:
(defthm cst-import-declaration-conc-equivs (implies (cst-matchp abnf::cst "import-declaration") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-type-import-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-type-import-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-import-on-demand-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-import-on-demand-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-static-import-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-static-import-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "static-import-on-demand-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "static-import-on-demand-declaration"))))))
Theorem:
(defthm cst-class-declaration-conc-equivs (implies (cst-matchp abnf::cst "class-declaration") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-class-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-class-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enum-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enum-declaration"))))))
Theorem:
(defthm cst-class-body-declaration-conc-equivs (implies (cst-matchp abnf::cst "class-body-declaration") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-member-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-member-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "instance-initializer") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "instance-initializer"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "static-initializer") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "static-initializer"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "constructor-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "constructor-declaration"))))))
Theorem:
(defthm cst-variable-initializer-conc-equivs (implies (cst-matchp abnf::cst "variable-initializer") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-initializer") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-initializer"))))))
Theorem:
(defthm cst-unann-type-conc-equivs (implies (cst-matchp abnf::cst "unann-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-primitive-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-primitive-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-reference-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-reference-type"))))))
Theorem:
(defthm cst-unann-reference-type-conc-equivs (implies (cst-matchp abnf::cst "unann-reference-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-or-interface-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-class-or-interface-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-type-variable") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-type-variable"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-array-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-array-type"))))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc-equivs (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-class-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-interface-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-interface-type"))))))
Theorem:
(defthm cst-exception-type-conc-equivs (implies (cst-matchp abnf::cst "exception-type") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-type"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-variable") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-variable"))))))
Theorem:
(defthm cst-interface-declaration-conc-equivs (implies (cst-matchp abnf::cst "interface-declaration") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-interface-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-interface-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation-type-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "annotation-type-declaration"))))))
Theorem:
(defthm cst-annotation-conc-equivs (implies (cst-matchp abnf::cst "annotation") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-annotation") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-annotation"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "marker-annotation") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "marker-annotation"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-element-annotation") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-element-annotation"))))))
Theorem:
(defthm cst-element-value-conc-equivs (implies (cst-matchp abnf::cst "element-value") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "conditional-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "element-value-array-initializer") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "element-value-array-initializer"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "annotation"))))))
Theorem:
(defthm cst-block-statement-conc-equivs (implies (cst-matchp abnf::cst "block-statement") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "local-variable-declaration-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-declaration"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement"))))))
Theorem:
(defthm cst-statement-conc-equivs (implies (cst-matchp abnf::cst "statement") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-without-trailing-substatement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "labeled-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "labeled-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-else-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-else-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "while-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "while-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "for-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "for-statement"))))))
Theorem:
(defthm cst-statement-no-short-if-conc-equivs (implies (cst-matchp abnf::cst "statement-no-short-if") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-without-trailing-substatement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "labeled-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "labeled-statement-no-short-if"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-else-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-else-statement-no-short-if"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "while-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "while-statement-no-short-if"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "for-statement-no-short-if"))))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc-equivs (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "block") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "empty-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "empty-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assert-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assert-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "switch-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "switch-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "do-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "do-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "break-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "break-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "continue-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "continue-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "return-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "return-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "synchronized-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "synchronized-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "throw-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "throw-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "try-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "try-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "yield-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "yield-statement"))))))
Theorem:
(defthm cst-statement-expression-conc-equivs (implies (cst-matchp abnf::cst "statement-expression") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "pre-increment-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "pre-increment-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "pre-decrement-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "pre-decrement-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-increment-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-increment-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-decrement-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-decrement-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "method-invocation") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "method-invocation"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-instance-creation-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-instance-creation-expression"))))))
Theorem:
(defthm cst-for-statement-conc-equivs (implies (cst-matchp abnf::cst "for-statement") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-for-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enhanced-for-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enhanced-for-statement"))))))
Theorem:
(defthm cst-for-statement-no-short-if-conc-equivs (implies (cst-matchp abnf::cst "for-statement-no-short-if") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-for-statement-no-short-if"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enhanced-for-statement-no-short-if") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enhanced-for-statement-no-short-if"))))))
Theorem:
(defthm cst-for-init-conc-equivs (implies (cst-matchp abnf::cst "for-init") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression-list") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-expression-list"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "local-variable-declaration"))))))
Theorem:
(defthm cst-variable-access-conc-equivs (implies (cst-matchp abnf::cst "variable-access") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "field-access") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "field-access"))))))
Theorem:
(defthm cst-expression-conc-equivs (implies (cst-matchp abnf::cst "expression") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "lambda-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "lambda-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment-expression"))))))
Theorem:
(defthm cst-primary-conc-equivs (implies (cst-matchp abnf::cst "primary") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary-no-new-array") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primary-no-new-array"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-creation-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-creation-expression"))))))
Theorem:
(defthm cst-postfix-expression-conc-equivs (implies (cst-matchp abnf::cst "postfix-expression") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primary"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-increment-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-increment-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-decrement-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-decrement-expression"))))))
Theorem:
(defthm cst-assignment-expression-conc-equivs (implies (cst-matchp abnf::cst "assignment-expression") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "conditional-expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment"))))))
Theorem:
(defthm cst-left-hand-side-conc-equivs (implies (cst-matchp abnf::cst "left-hand-side") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "field-access") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "field-access"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-access") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-access"))))))
Theorem:
(defthm cst-lambda-body-conc-equivs (implies (cst-matchp abnf::cst "lambda-body") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "block") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block"))))))
Function:
(defun cst-unicode-input-character-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unicode-input-character"))) (let ((__function__ 'cst-unicode-input-character-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unicode-escape")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "raw-input-character")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-unicode-input-character-conc? (b* ((number (cst-unicode-input-character-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc?-possibilities (b* ((number (cst-unicode-input-character-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-unicode-input-character-conc? abnf::cst)))))
Theorem:
(defthm cst-unicode-input-character-conc?-of-tree-fix-cst (equal (cst-unicode-input-character-conc? (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc? abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc? abnf::cst) (cst-unicode-input-character-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-unicode-input-character-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "unicode-input-character") (iff (equal (cst-unicode-input-character-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unicode-escape"))))
Theorem:
(defthm cst-unicode-input-character-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "unicode-input-character") (iff (equal (cst-unicode-input-character-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "raw-input-character"))))
Function:
(defun cst-input-element-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "input-element"))) (let ((__function__ 'cst-input-element-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "white-space")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "comment")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "token")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-input-element-conc? (b* ((number (cst-input-element-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc?-possibilities (b* ((number (cst-input-element-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-input-element-conc? abnf::cst)))))
Theorem:
(defthm cst-input-element-conc?-of-tree-fix-cst (equal (cst-input-element-conc? (abnf::tree-fix abnf::cst)) (cst-input-element-conc? abnf::cst)))
Theorem:
(defthm cst-input-element-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc? abnf::cst) (cst-input-element-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-input-element-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "input-element") (iff (equal (cst-input-element-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "white-space"))))
Theorem:
(defthm cst-input-element-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "input-element") (iff (equal (cst-input-element-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "comment"))))
Theorem:
(defthm cst-input-element-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "input-element") (iff (equal (cst-input-element-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "token"))))
Function:
(defun cst-token-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "token"))) (let ((__function__ 'cst-token-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "identifier")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "keyword")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "literal")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "separator")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "operator")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-token-conc? (b* ((number (cst-token-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc?-possibilities (b* ((number (cst-token-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5))) :rule-classes ((:forward-chaining :trigger-terms ((cst-token-conc? abnf::cst)))))
Theorem:
(defthm cst-token-conc?-of-tree-fix-cst (equal (cst-token-conc? (abnf::tree-fix abnf::cst)) (cst-token-conc? abnf::cst)))
Theorem:
(defthm cst-token-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc? abnf::cst) (cst-token-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-token-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier"))))
Theorem:
(defthm cst-token-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "keyword"))))
Theorem:
(defthm cst-token-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "literal"))))
Theorem:
(defthm cst-token-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "separator"))))
Theorem:
(defthm cst-token-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "operator"))))
Function:
(defun cst-comment-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "comment"))) (let ((__function__ 'cst-comment-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "traditional-comment")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "end-of-line-comment")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-comment-conc? (b* ((number (cst-comment-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc?-possibilities (b* ((number (cst-comment-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-comment-conc? abnf::cst)))))
Theorem:
(defthm cst-comment-conc?-of-tree-fix-cst (equal (cst-comment-conc? (abnf::tree-fix abnf::cst)) (cst-comment-conc? abnf::cst)))
Theorem:
(defthm cst-comment-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc? abnf::cst) (cst-comment-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-comment-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "comment") (iff (equal (cst-comment-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "traditional-comment"))))
Theorem:
(defthm cst-comment-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "comment") (iff (equal (cst-comment-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "end-of-line-comment"))))
Function:
(defun cst-not-star-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "not-star"))) (let ((__function__ 'cst-not-star-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "line-terminator")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-not-star-conc? (b* ((number (cst-not-star-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc?-possibilities (b* ((number (cst-not-star-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-not-star-conc? abnf::cst)))))
Theorem:
(defthm cst-not-star-conc?-of-tree-fix-cst (equal (cst-not-star-conc? (abnf::tree-fix abnf::cst)) (cst-not-star-conc? abnf::cst)))
Theorem:
(defthm cst-not-star-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc? abnf::cst) (cst-not-star-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-not-star-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "not-star") (iff (equal (cst-not-star-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character"))))
Theorem:
(defthm cst-not-star-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "not-star") (iff (equal (cst-not-star-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "line-terminator"))))
Function:
(defun cst-not-star-not-slash-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "not-star-not-slash"))) (let ((__function__ 'cst-not-star-not-slash-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "line-terminator")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-not-star-not-slash-conc? (b* ((number (cst-not-star-not-slash-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc?-possibilities (b* ((number (cst-not-star-not-slash-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-not-star-not-slash-conc? abnf::cst)))))
Theorem:
(defthm cst-not-star-not-slash-conc?-of-tree-fix-cst (equal (cst-not-star-not-slash-conc? (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc? abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc? abnf::cst) (cst-not-star-not-slash-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-not-star-not-slash-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "not-star-not-slash") (iff (equal (cst-not-star-not-slash-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character"))))
Theorem:
(defthm cst-not-star-not-slash-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "not-star-not-slash") (iff (equal (cst-not-star-not-slash-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "line-terminator"))))
Function:
(defun cst-literal-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "literal"))) (let ((__function__ 'cst-literal-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integer-literal")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "floating-point-literal")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "boolean-literal")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-literal")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "string-literal")) 5) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "null-literal")) 6) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-literal-conc? (b* ((number (cst-literal-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc?-possibilities (b* ((number (cst-literal-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6))) :rule-classes ((:forward-chaining :trigger-terms ((cst-literal-conc? abnf::cst)))))
Theorem:
(defthm cst-literal-conc?-of-tree-fix-cst (equal (cst-literal-conc? (abnf::tree-fix abnf::cst)) (cst-literal-conc? abnf::cst)))
Theorem:
(defthm cst-literal-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc? abnf::cst) (cst-literal-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-literal-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-literal"))))
Theorem:
(defthm cst-literal-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "floating-point-literal"))))
Theorem:
(defthm cst-literal-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "boolean-literal"))))
Theorem:
(defthm cst-literal-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-literal"))))
Theorem:
(defthm cst-literal-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "string-literal"))))
Theorem:
(defthm cst-literal-conc?-6-iff-match-conc (implies (cst-matchp abnf::cst "literal") (iff (equal (cst-literal-conc? abnf::cst) 6) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "null-literal"))))
Function:
(defun cst-integer-literal-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "integer-literal"))) (let ((__function__ 'cst-integer-literal-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-integer-literal")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hex-integer-literal")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "octal-integer-literal")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "binary-integer-literal")) 4) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-integer-literal-conc? (b* ((number (cst-integer-literal-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc?-possibilities (b* ((number (cst-integer-literal-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((cst-integer-literal-conc? abnf::cst)))))
Theorem:
(defthm cst-integer-literal-conc?-of-tree-fix-cst (equal (cst-integer-literal-conc? (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc? abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc? abnf::cst) (cst-integer-literal-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-integer-literal-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "integer-literal") (iff (equal (cst-integer-literal-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "integer-literal") (iff (equal (cst-integer-literal-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hex-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "integer-literal") (iff (equal (cst-integer-literal-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-integer-literal"))))
Theorem:
(defthm cst-integer-literal-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "integer-literal") (iff (equal (cst-integer-literal-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "binary-integer-literal"))))
Function:
(defun cst-floating-point-literal-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "floating-point-literal"))) (let ((__function__ 'cst-floating-point-literal-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-floating-point-literal")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-floating-point-literal")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-floating-point-literal-conc? (b* ((number (cst-floating-point-literal-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc?-possibilities (b* ((number (cst-floating-point-literal-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-floating-point-literal-conc? abnf::cst)))))
Theorem:
(defthm cst-floating-point-literal-conc?-of-tree-fix-cst (equal (cst-floating-point-literal-conc? (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc? abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc? abnf::cst) (cst-floating-point-literal-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-floating-point-literal-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "floating-point-literal") (iff (equal (cst-floating-point-literal-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-point-literal"))))
Theorem:
(defthm cst-floating-point-literal-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "floating-point-literal") (iff (equal (cst-floating-point-literal-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-floating-point-literal"))))
Function:
(defun cst-string-character-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "string-character"))) (let ((__function__ 'cst-string-character-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "input-character")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-string-character-conc? (b* ((number (cst-string-character-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc?-possibilities (b* ((number (cst-string-character-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-string-character-conc? abnf::cst)))))
Theorem:
(defthm cst-string-character-conc?-of-tree-fix-cst (equal (cst-string-character-conc? (abnf::tree-fix abnf::cst)) (cst-string-character-conc? abnf::cst)))
Theorem:
(defthm cst-string-character-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc? abnf::cst) (cst-string-character-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-string-character-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "string-character") (iff (equal (cst-string-character-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "input-character"))))
Theorem:
(defthm cst-string-character-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "string-character") (iff (equal (cst-string-character-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence"))))
Function:
(defun cst-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type"))) (let ((__function__ 'cst-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primitive-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "reference-type")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-type-conc? (b* ((number (cst-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc?-possibilities (b* ((number (cst-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-type-conc? abnf::cst)))))
Theorem:
(defthm cst-type-conc?-of-tree-fix-cst (equal (cst-type-conc? (abnf::tree-fix abnf::cst)) (cst-type-conc? abnf::cst)))
Theorem:
(defthm cst-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc? abnf::cst) (cst-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "type") (iff (equal (cst-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primitive-type"))))
Theorem:
(defthm cst-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "type") (iff (equal (cst-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "reference-type"))))
Function:
(defun cst-numeric-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "numeric-type"))) (let ((__function__ 'cst-numeric-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integral-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "floating-point-type")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-numeric-type-conc? (b* ((number (cst-numeric-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc?-possibilities (b* ((number (cst-numeric-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-numeric-type-conc? abnf::cst)))))
Theorem:
(defthm cst-numeric-type-conc?-of-tree-fix-cst (equal (cst-numeric-type-conc? (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc? abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc? abnf::cst) (cst-numeric-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-numeric-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "numeric-type") (iff (equal (cst-numeric-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integral-type"))))
Theorem:
(defthm cst-numeric-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "numeric-type") (iff (equal (cst-numeric-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "floating-point-type"))))
Function:
(defun cst-reference-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "reference-type"))) (let ((__function__ 'cst-reference-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-or-interface-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-variable")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-type")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-reference-type-conc? (b* ((number (cst-reference-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc?-possibilities (b* ((number (cst-reference-type-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-reference-type-conc? abnf::cst)))))
Theorem:
(defthm cst-reference-type-conc?-of-tree-fix-cst (equal (cst-reference-type-conc? (abnf::tree-fix abnf::cst)) (cst-reference-type-conc? abnf::cst)))
Theorem:
(defthm cst-reference-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc? abnf::cst) (cst-reference-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-reference-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "reference-type") (iff (equal (cst-reference-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-or-interface-type"))))
Theorem:
(defthm cst-reference-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "reference-type") (iff (equal (cst-reference-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-variable"))))
Theorem:
(defthm cst-reference-type-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "reference-type") (iff (equal (cst-reference-type-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-type"))))
Function:
(defun cst-class-or-interface-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "class-or-interface-type"))) (let ((__function__ 'cst-class-or-interface-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "interface-type")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-class-or-interface-type-conc? (b* ((number (cst-class-or-interface-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc?-possibilities (b* ((number (cst-class-or-interface-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-class-or-interface-type-conc? abnf::cst)))))
Theorem:
(defthm cst-class-or-interface-type-conc?-of-tree-fix-cst (equal (cst-class-or-interface-type-conc? (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc? abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc? abnf::cst) (cst-class-or-interface-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-class-or-interface-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "class-or-interface-type") (iff (equal (cst-class-or-interface-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type"))))
Theorem:
(defthm cst-class-or-interface-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "class-or-interface-type") (iff (equal (cst-class-or-interface-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "interface-type"))))
Function:
(defun cst-type-argument-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-argument"))) (let ((__function__ 'cst-type-argument-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "reference-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "wildcard")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-type-argument-conc? (b* ((number (cst-type-argument-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc?-possibilities (b* ((number (cst-type-argument-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-type-argument-conc? abnf::cst)))))
Theorem:
(defthm cst-type-argument-conc?-of-tree-fix-cst (equal (cst-type-argument-conc? (abnf::tree-fix abnf::cst)) (cst-type-argument-conc? abnf::cst)))
Theorem:
(defthm cst-type-argument-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc? abnf::cst) (cst-type-argument-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-type-argument-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "type-argument") (iff (equal (cst-type-argument-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "reference-type"))))
Theorem:
(defthm cst-type-argument-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "type-argument") (iff (equal (cst-type-argument-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "wildcard"))))
Function:
(defun cst-compilation-unit-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "compilation-unit"))) (let ((__function__ 'cst-compilation-unit-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "ordinary-compilation-unit")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "modular-compilation-unit")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-compilation-unit-conc? (b* ((number (cst-compilation-unit-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc?-possibilities (b* ((number (cst-compilation-unit-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-compilation-unit-conc? abnf::cst)))))
Theorem:
(defthm cst-compilation-unit-conc?-of-tree-fix-cst (equal (cst-compilation-unit-conc? (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc? abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc? abnf::cst) (cst-compilation-unit-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-compilation-unit-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "compilation-unit") (iff (equal (cst-compilation-unit-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "ordinary-compilation-unit"))))
Theorem:
(defthm cst-compilation-unit-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "compilation-unit") (iff (equal (cst-compilation-unit-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "modular-compilation-unit"))))
Function:
(defun cst-import-declaration-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "import-declaration"))) (let ((__function__ 'cst-import-declaration-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-type-import-declaration")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-import-on-demand-declaration")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-static-import-declaration")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "static-import-on-demand-declaration")) 4) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-import-declaration-conc? (b* ((number (cst-import-declaration-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc?-possibilities (b* ((number (cst-import-declaration-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((cst-import-declaration-conc? abnf::cst)))))
Theorem:
(defthm cst-import-declaration-conc?-of-tree-fix-cst (equal (cst-import-declaration-conc? (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc? abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc? abnf::cst) (cst-import-declaration-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-import-declaration-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "import-declaration") (iff (equal (cst-import-declaration-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-type-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "import-declaration") (iff (equal (cst-import-declaration-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-import-on-demand-declaration"))))
Theorem:
(defthm cst-import-declaration-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "import-declaration") (iff (equal (cst-import-declaration-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-static-import-declaration"))))
Theorem:
(defthm cst-import-declaration-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "import-declaration") (iff (equal (cst-import-declaration-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "static-import-on-demand-declaration"))))
Function:
(defun cst-class-declaration-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "class-declaration"))) (let ((__function__ 'cst-class-declaration-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-class-declaration")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enum-declaration")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-class-declaration-conc? (b* ((number (cst-class-declaration-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc?-possibilities (b* ((number (cst-class-declaration-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-class-declaration-conc? abnf::cst)))))
Theorem:
(defthm cst-class-declaration-conc?-of-tree-fix-cst (equal (cst-class-declaration-conc? (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc? abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc? abnf::cst) (cst-class-declaration-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-class-declaration-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "class-declaration") (iff (equal (cst-class-declaration-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-class-declaration"))))
Theorem:
(defthm cst-class-declaration-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "class-declaration") (iff (equal (cst-class-declaration-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enum-declaration"))))
Function:
(defun cst-class-body-declaration-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "class-body-declaration"))) (let ((__function__ 'cst-class-body-declaration-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-member-declaration")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "instance-initializer")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "static-initializer")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "constructor-declaration")) 4) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-class-body-declaration-conc? (b* ((number (cst-class-body-declaration-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc?-possibilities (b* ((number (cst-class-body-declaration-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((cst-class-body-declaration-conc? abnf::cst)))))
Theorem:
(defthm cst-class-body-declaration-conc?-of-tree-fix-cst (equal (cst-class-body-declaration-conc? (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc? abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc? abnf::cst) (cst-class-body-declaration-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-class-body-declaration-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "class-body-declaration") (iff (equal (cst-class-body-declaration-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-member-declaration"))))
Theorem:
(defthm cst-class-body-declaration-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "class-body-declaration") (iff (equal (cst-class-body-declaration-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "instance-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "class-body-declaration") (iff (equal (cst-class-body-declaration-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "static-initializer"))))
Theorem:
(defthm cst-class-body-declaration-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "class-body-declaration") (iff (equal (cst-class-body-declaration-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "constructor-declaration"))))
Function:
(defun cst-variable-initializer-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-initializer"))) (let ((__function__ 'cst-variable-initializer-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-initializer")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-variable-initializer-conc? (b* ((number (cst-variable-initializer-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc?-possibilities (b* ((number (cst-variable-initializer-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-variable-initializer-conc? abnf::cst)))))
Theorem:
(defthm cst-variable-initializer-conc?-of-tree-fix-cst (equal (cst-variable-initializer-conc? (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc? abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc? abnf::cst) (cst-variable-initializer-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-variable-initializer-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "variable-initializer") (iff (equal (cst-variable-initializer-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression"))))
Theorem:
(defthm cst-variable-initializer-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "variable-initializer") (iff (equal (cst-variable-initializer-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-initializer"))))
Function:
(defun cst-unann-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-type"))) (let ((__function__ 'cst-unann-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-primitive-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-reference-type")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-unann-type-conc? (b* ((number (cst-unann-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc?-possibilities (b* ((number (cst-unann-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-unann-type-conc? abnf::cst)))))
Theorem:
(defthm cst-unann-type-conc?-of-tree-fix-cst (equal (cst-unann-type-conc? (abnf::tree-fix abnf::cst)) (cst-unann-type-conc? abnf::cst)))
Theorem:
(defthm cst-unann-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc? abnf::cst) (cst-unann-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-unann-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "unann-type") (iff (equal (cst-unann-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-primitive-type"))))
Theorem:
(defthm cst-unann-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "unann-type") (iff (equal (cst-unann-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-reference-type"))))
Function:
(defun cst-unann-reference-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-reference-type"))) (let ((__function__ 'cst-unann-reference-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-class-or-interface-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-type-variable")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-array-type")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-unann-reference-type-conc? (b* ((number (cst-unann-reference-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc?-possibilities (b* ((number (cst-unann-reference-type-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-unann-reference-type-conc? abnf::cst)))))
Theorem:
(defthm cst-unann-reference-type-conc?-of-tree-fix-cst (equal (cst-unann-reference-type-conc? (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc? abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc? abnf::cst) (cst-unann-reference-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-unann-reference-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "unann-reference-type") (iff (equal (cst-unann-reference-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-or-interface-type"))))
Theorem:
(defthm cst-unann-reference-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "unann-reference-type") (iff (equal (cst-unann-reference-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-type-variable"))))
Theorem:
(defthm cst-unann-reference-type-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "unann-reference-type") (iff (equal (cst-unann-reference-type-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-array-type"))))
Function:
(defun cst-unann-class-or-interface-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-class-or-interface-type"))) (let ((__function__ 'cst-unann-class-or-interface-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-class-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "unann-interface-type")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-unann-class-or-interface-type-conc? (b* ((number (cst-unann-class-or-interface-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc?-possibilities (b* ((number (cst-unann-class-or-interface-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-unann-class-or-interface-type-conc? abnf::cst)))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc?-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc? (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc? abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc? abnf::cst) (cst-unann-class-or-interface-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-unann-class-or-interface-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (iff (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-class-type"))))
Theorem:
(defthm cst-unann-class-or-interface-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "unann-class-or-interface-type") (iff (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "unann-interface-type"))))
Function:
(defun cst-exception-type-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exception-type"))) (let ((__function__ 'cst-exception-type-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-type")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "type-variable")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-exception-type-conc? (b* ((number (cst-exception-type-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc?-possibilities (b* ((number (cst-exception-type-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-exception-type-conc? abnf::cst)))))
Theorem:
(defthm cst-exception-type-conc?-of-tree-fix-cst (equal (cst-exception-type-conc? (abnf::tree-fix abnf::cst)) (cst-exception-type-conc? abnf::cst)))
Theorem:
(defthm cst-exception-type-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc? abnf::cst) (cst-exception-type-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-exception-type-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "exception-type") (iff (equal (cst-exception-type-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-type"))))
Theorem:
(defthm cst-exception-type-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "exception-type") (iff (equal (cst-exception-type-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-variable"))))
Function:
(defun cst-interface-declaration-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-declaration"))) (let ((__function__ 'cst-interface-declaration-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-interface-declaration")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "annotation-type-declaration")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-interface-declaration-conc? (b* ((number (cst-interface-declaration-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc?-possibilities (b* ((number (cst-interface-declaration-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-interface-declaration-conc? abnf::cst)))))
Theorem:
(defthm cst-interface-declaration-conc?-of-tree-fix-cst (equal (cst-interface-declaration-conc? (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc? abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc? abnf::cst) (cst-interface-declaration-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-interface-declaration-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "interface-declaration") (iff (equal (cst-interface-declaration-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-interface-declaration"))))
Theorem:
(defthm cst-interface-declaration-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "interface-declaration") (iff (equal (cst-interface-declaration-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation-type-declaration"))))
Function:
(defun cst-annotation-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "annotation"))) (let ((__function__ 'cst-annotation-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "normal-annotation")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "marker-annotation")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "single-element-annotation")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-annotation-conc? (b* ((number (cst-annotation-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc?-possibilities (b* ((number (cst-annotation-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-annotation-conc? abnf::cst)))))
Theorem:
(defthm cst-annotation-conc?-of-tree-fix-cst (equal (cst-annotation-conc? (abnf::tree-fix abnf::cst)) (cst-annotation-conc? abnf::cst)))
Theorem:
(defthm cst-annotation-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc? abnf::cst) (cst-annotation-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-annotation-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "annotation") (iff (equal (cst-annotation-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "normal-annotation"))))
Theorem:
(defthm cst-annotation-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "annotation") (iff (equal (cst-annotation-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "marker-annotation"))))
Theorem:
(defthm cst-annotation-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "annotation") (iff (equal (cst-annotation-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "single-element-annotation"))))
Function:
(defun cst-element-value-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "element-value"))) (let ((__function__ 'cst-element-value-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "conditional-expression")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "element-value-array-initializer")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "annotation")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-element-value-conc? (b* ((number (cst-element-value-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc?-possibilities (b* ((number (cst-element-value-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-element-value-conc? abnf::cst)))))
Theorem:
(defthm cst-element-value-conc?-of-tree-fix-cst (equal (cst-element-value-conc? (abnf::tree-fix abnf::cst)) (cst-element-value-conc? abnf::cst)))
Theorem:
(defthm cst-element-value-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc? abnf::cst) (cst-element-value-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-element-value-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "element-value") (iff (equal (cst-element-value-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression"))))
Theorem:
(defthm cst-element-value-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "element-value") (iff (equal (cst-element-value-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "element-value-array-initializer"))))
Theorem:
(defthm cst-element-value-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "element-value") (iff (equal (cst-element-value-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "annotation"))))
Function:
(defun cst-block-statement-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "block-statement"))) (let ((__function__ 'cst-block-statement-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "local-variable-declaration-statement")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-declaration")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-block-statement-conc? (b* ((number (cst-block-statement-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc?-possibilities (b* ((number (cst-block-statement-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-block-statement-conc? abnf::cst)))))
Theorem:
(defthm cst-block-statement-conc?-of-tree-fix-cst (equal (cst-block-statement-conc? (abnf::tree-fix abnf::cst)) (cst-block-statement-conc? abnf::cst)))
Theorem:
(defthm cst-block-statement-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc? abnf::cst) (cst-block-statement-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-block-statement-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "block-statement") (iff (equal (cst-block-statement-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration-statement"))))
Theorem:
(defthm cst-block-statement-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "block-statement") (iff (equal (cst-block-statement-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-declaration"))))
Theorem:
(defthm cst-block-statement-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "block-statement") (iff (equal (cst-block-statement-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement"))))
Function:
(defun cst-statement-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement"))) (let ((__function__ 'cst-statement-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-without-trailing-substatement")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "labeled-statement")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-statement")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-else-statement")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "while-statement")) 5) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "for-statement")) 6) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-statement-conc? (b* ((number (cst-statement-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc?-possibilities (b* ((number (cst-statement-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6))) :rule-classes ((:forward-chaining :trigger-terms ((cst-statement-conc? abnf::cst)))))
Theorem:
(defthm cst-statement-conc?-of-tree-fix-cst (equal (cst-statement-conc? (abnf::tree-fix abnf::cst)) (cst-statement-conc? abnf::cst)))
Theorem:
(defthm cst-statement-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc? abnf::cst) (cst-statement-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-statement-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "labeled-statement"))))
Theorem:
(defthm cst-statement-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-statement"))))
Theorem:
(defthm cst-statement-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-else-statement"))))
Theorem:
(defthm cst-statement-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "while-statement"))))
Theorem:
(defthm cst-statement-conc?-6-iff-match-conc (implies (cst-matchp abnf::cst "statement") (iff (equal (cst-statement-conc? abnf::cst) 6) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "for-statement"))))
Function:
(defun cst-statement-no-short-if-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement-no-short-if"))) (let ((__function__ 'cst-statement-no-short-if-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-without-trailing-substatement")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "labeled-statement-no-short-if")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "if-then-else-statement-no-short-if")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "while-statement-no-short-if")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "for-statement-no-short-if")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-statement-no-short-if-conc? (b* ((number (cst-statement-no-short-if-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc?-possibilities (b* ((number (cst-statement-no-short-if-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5))) :rule-classes ((:forward-chaining :trigger-terms ((cst-statement-no-short-if-conc? abnf::cst)))))
Theorem:
(defthm cst-statement-no-short-if-conc?-of-tree-fix-cst (equal (cst-statement-no-short-if-conc? (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc? abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc? abnf::cst) (cst-statement-no-short-if-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-statement-no-short-if-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "statement-no-short-if") (iff (equal (cst-statement-no-short-if-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-without-trailing-substatement"))))
Theorem:
(defthm cst-statement-no-short-if-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "statement-no-short-if") (iff (equal (cst-statement-no-short-if-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "labeled-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "statement-no-short-if") (iff (equal (cst-statement-no-short-if-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "if-then-else-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "statement-no-short-if") (iff (equal (cst-statement-no-short-if-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "while-statement-no-short-if"))))
Theorem:
(defthm cst-statement-no-short-if-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "statement-no-short-if") (iff (equal (cst-statement-no-short-if-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "for-statement-no-short-if"))))
Function:
(defun cst-statement-without-trailing-substatement-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement-without-trailing-substatement"))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "empty-statement")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-statement")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assert-statement")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "switch-statement")) 5) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "do-statement")) 6) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "break-statement")) 7) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "continue-statement")) 8) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "return-statement")) 9) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "synchronized-statement")) 10) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "throw-statement")) 11) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "try-statement")) 12) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "yield-statement")) 13) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-statement-without-trailing-substatement-conc? (b* ((number (cst-statement-without-trailing-substatement-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-possibilities (b* ((number (cst-statement-without-trailing-substatement-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6) (equal number 7) (equal number 8) (equal number 9) (equal number 10) (equal number 11) (equal number 12) (equal number 13))) :rule-classes ((:forward-chaining :trigger-terms ((cst-statement-without-trailing-substatement-conc? abnf::cst)))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc? (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc? abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) (cst-statement-without-trailing-substatement-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "block"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "empty-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assert-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "switch-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-6-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "do-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-7-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "break-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-8-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "continue-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-9-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "return-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-10-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "synchronized-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-11-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "throw-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-12-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "try-statement"))))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc?-13-iff-match-conc (implies (cst-matchp abnf::cst "statement-without-trailing-substatement") (iff (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "yield-statement"))))
Function:
(defun cst-statement-expression-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement-expression"))) (let ((__function__ 'cst-statement-expression-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "pre-increment-expression")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "pre-decrement-expression")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-increment-expression")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-decrement-expression")) 5) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "method-invocation")) 6) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "class-instance-creation-expression")) 7) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-statement-expression-conc? (b* ((number (cst-statement-expression-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc?-possibilities (b* ((number (cst-statement-expression-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6) (equal number 7))) :rule-classes ((:forward-chaining :trigger-terms ((cst-statement-expression-conc? abnf::cst)))))
Theorem:
(defthm cst-statement-expression-conc?-of-tree-fix-cst (equal (cst-statement-expression-conc? (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc? abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc? abnf::cst) (cst-statement-expression-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-statement-expression-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment"))))
Theorem:
(defthm cst-statement-expression-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "pre-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "pre-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-increment-expression"))))
Theorem:
(defthm cst-statement-expression-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-decrement-expression"))))
Theorem:
(defthm cst-statement-expression-conc?-6-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 6) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "method-invocation"))))
Theorem:
(defthm cst-statement-expression-conc?-7-iff-match-conc (implies (cst-matchp abnf::cst "statement-expression") (iff (equal (cst-statement-expression-conc? abnf::cst) 7) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "class-instance-creation-expression"))))
Function:
(defun cst-for-statement-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-statement"))) (let ((__function__ 'cst-for-statement-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-for-statement")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enhanced-for-statement")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-for-statement-conc? (b* ((number (cst-for-statement-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc?-possibilities (b* ((number (cst-for-statement-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-for-statement-conc? abnf::cst)))))
Theorem:
(defthm cst-for-statement-conc?-of-tree-fix-cst (equal (cst-for-statement-conc? (abnf::tree-fix abnf::cst)) (cst-for-statement-conc? abnf::cst)))
Theorem:
(defthm cst-for-statement-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc? abnf::cst) (cst-for-statement-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-for-statement-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "for-statement") (iff (equal (cst-for-statement-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement"))))
Theorem:
(defthm cst-for-statement-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "for-statement") (iff (equal (cst-for-statement-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enhanced-for-statement"))))
Function:
(defun cst-for-statement-no-short-if-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-statement-no-short-if"))) (let ((__function__ 'cst-for-statement-no-short-if-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-for-statement-no-short-if")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enhanced-for-statement-no-short-if")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-for-statement-no-short-if-conc? (b* ((number (cst-for-statement-no-short-if-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc?-possibilities (b* ((number (cst-for-statement-no-short-if-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-for-statement-no-short-if-conc? abnf::cst)))))
Theorem:
(defthm cst-for-statement-no-short-if-conc?-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc? (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc? abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc? abnf::cst) (cst-for-statement-no-short-if-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-for-statement-no-short-if-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "for-statement-no-short-if") (iff (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-for-statement-no-short-if"))))
Theorem:
(defthm cst-for-statement-no-short-if-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "for-statement-no-short-if") (iff (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enhanced-for-statement-no-short-if"))))
Function:
(defun cst-for-init-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-init"))) (let ((__function__ 'cst-for-init-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement-expression-list")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "local-variable-declaration")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-for-init-conc? (b* ((number (cst-for-init-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc?-possibilities (b* ((number (cst-for-init-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-for-init-conc? abnf::cst)))))
Theorem:
(defthm cst-for-init-conc?-of-tree-fix-cst (equal (cst-for-init-conc? (abnf::tree-fix abnf::cst)) (cst-for-init-conc? abnf::cst)))
Theorem:
(defthm cst-for-init-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc? abnf::cst) (cst-for-init-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-for-init-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "for-init") (iff (equal (cst-for-init-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement-expression-list"))))
Theorem:
(defthm cst-for-init-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "for-init") (iff (equal (cst-for-init-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "local-variable-declaration"))))
Function:
(defun cst-variable-access-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-access"))) (let ((__function__ 'cst-variable-access-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "field-access")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-variable-access-conc? (b* ((number (cst-variable-access-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc?-possibilities (b* ((number (cst-variable-access-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-variable-access-conc? abnf::cst)))))
Theorem:
(defthm cst-variable-access-conc?-of-tree-fix-cst (equal (cst-variable-access-conc? (abnf::tree-fix abnf::cst)) (cst-variable-access-conc? abnf::cst)))
Theorem:
(defthm cst-variable-access-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc? abnf::cst) (cst-variable-access-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-variable-access-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "variable-access") (iff (equal (cst-variable-access-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name"))))
Theorem:
(defthm cst-variable-access-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "variable-access") (iff (equal (cst-variable-access-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "field-access"))))
Function:
(defun cst-expression-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "expression"))) (let ((__function__ 'cst-expression-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "lambda-expression")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment-expression")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-expression-conc? (b* ((number (cst-expression-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc?-possibilities (b* ((number (cst-expression-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-expression-conc? abnf::cst)))))
Theorem:
(defthm cst-expression-conc?-of-tree-fix-cst (equal (cst-expression-conc? (abnf::tree-fix abnf::cst)) (cst-expression-conc? abnf::cst)))
Theorem:
(defthm cst-expression-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc? abnf::cst) (cst-expression-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-expression-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "expression") (iff (equal (cst-expression-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "lambda-expression"))))
Theorem:
(defthm cst-expression-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "expression") (iff (equal (cst-expression-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment-expression"))))
Function:
(defun cst-primary-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "primary"))) (let ((__function__ 'cst-primary-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primary-no-new-array")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-creation-expression")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-primary-conc? (b* ((number (cst-primary-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc?-possibilities (b* ((number (cst-primary-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-primary-conc? abnf::cst)))))
Theorem:
(defthm cst-primary-conc?-of-tree-fix-cst (equal (cst-primary-conc? (abnf::tree-fix abnf::cst)) (cst-primary-conc? abnf::cst)))
Theorem:
(defthm cst-primary-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc? abnf::cst) (cst-primary-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-primary-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "primary") (iff (equal (cst-primary-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary-no-new-array"))))
Theorem:
(defthm cst-primary-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "primary") (iff (equal (cst-primary-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-creation-expression"))))
Function:
(defun cst-postfix-expression-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "postfix-expression"))) (let ((__function__ 'cst-postfix-expression-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "primary")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-increment-expression")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "post-decrement-expression")) 4) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-postfix-expression-conc? (b* ((number (cst-postfix-expression-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc?-possibilities (b* ((number (cst-postfix-expression-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((cst-postfix-expression-conc? abnf::cst)))))
Theorem:
(defthm cst-postfix-expression-conc?-of-tree-fix-cst (equal (cst-postfix-expression-conc? (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc? abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc? abnf::cst) (cst-postfix-expression-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-postfix-expression-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "postfix-expression") (iff (equal (cst-postfix-expression-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "primary"))))
Theorem:
(defthm cst-postfix-expression-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "postfix-expression") (iff (equal (cst-postfix-expression-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name"))))
Theorem:
(defthm cst-postfix-expression-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "postfix-expression") (iff (equal (cst-postfix-expression-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-increment-expression"))))
Theorem:
(defthm cst-postfix-expression-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "postfix-expression") (iff (equal (cst-postfix-expression-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "post-decrement-expression"))))
Function:
(defun cst-assignment-expression-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "assignment-expression"))) (let ((__function__ 'cst-assignment-expression-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "conditional-expression")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "assignment")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-assignment-expression-conc? (b* ((number (cst-assignment-expression-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc?-possibilities (b* ((number (cst-assignment-expression-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-assignment-expression-conc? abnf::cst)))))
Theorem:
(defthm cst-assignment-expression-conc?-of-tree-fix-cst (equal (cst-assignment-expression-conc? (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc? abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc? abnf::cst) (cst-assignment-expression-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-assignment-expression-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "assignment-expression") (iff (equal (cst-assignment-expression-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "conditional-expression"))))
Theorem:
(defthm cst-assignment-expression-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "assignment-expression") (iff (equal (cst-assignment-expression-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment"))))
Function:
(defun cst-left-hand-side-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "left-hand-side"))) (let ((__function__ 'cst-left-hand-side-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression-name")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "field-access")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "array-access")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-left-hand-side-conc? (b* ((number (cst-left-hand-side-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc?-possibilities (b* ((number (cst-left-hand-side-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-left-hand-side-conc? abnf::cst)))))
Theorem:
(defthm cst-left-hand-side-conc?-of-tree-fix-cst (equal (cst-left-hand-side-conc? (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc? abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc? abnf::cst) (cst-left-hand-side-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-left-hand-side-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "left-hand-side") (iff (equal (cst-left-hand-side-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression-name"))))
Theorem:
(defthm cst-left-hand-side-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "left-hand-side") (iff (equal (cst-left-hand-side-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "field-access"))))
Theorem:
(defthm cst-left-hand-side-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "left-hand-side") (iff (equal (cst-left-hand-side-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "array-access"))))
Function:
(defun cst-lambda-body-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lambda-body"))) (let ((__function__ 'cst-lambda-body-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "expression")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-lambda-body-conc? (b* ((number (cst-lambda-body-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc?-possibilities (b* ((number (cst-lambda-body-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-lambda-body-conc? abnf::cst)))))
Theorem:
(defthm cst-lambda-body-conc?-of-tree-fix-cst (equal (cst-lambda-body-conc? (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc? abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc? abnf::cst) (cst-lambda-body-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-lambda-body-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "lambda-body") (iff (equal (cst-lambda-body-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "expression"))))
Theorem:
(defthm cst-lambda-body-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "lambda-body") (iff (equal (cst-lambda-body-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "block"))))
Function:
(defun cst-unicode-input-character-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unicode-input-character-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unicode-input-character-conc1 (b* ((abnf::cstss (cst-unicode-input-character-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-unicode-input-character-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unicode-escape"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-of-tree-fix-cst (equal (cst-unicode-input-character-conc1 (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc1 abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc1 abnf::cst) (cst-unicode-input-character-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-input-character-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unicode-input-character-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unicode-input-character-conc2 (b* ((abnf::cstss (cst-unicode-input-character-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-unicode-input-character-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-of-tree-fix-cst (equal (cst-unicode-input-character-conc2 (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc2 abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc2 abnf::cst) (cst-unicode-input-character-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-escape-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unicode-escape"))) (let ((__function__ 'cst-unicode-escape-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unicode-escape-conc (b* ((abnf::cstss (cst-unicode-escape-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-escape-conc-match (implies (cst-matchp abnf::cst "unicode-escape") (b* ((abnf::cstss (cst-unicode-escape-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-escape-conc-of-tree-fix-cst (equal (cst-unicode-escape-conc (abnf::tree-fix abnf::cst)) (cst-unicode-escape-conc abnf::cst)))
Theorem:
(defthm cst-unicode-escape-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-escape-conc abnf::cst) (cst-unicode-escape-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-marker-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unicode-marker"))) (let ((__function__ 'cst-unicode-marker-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unicode-marker-conc (b* ((abnf::cstss (cst-unicode-marker-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-marker-conc-match (implies (cst-matchp abnf::cst "unicode-marker") (b* ((abnf::cstss (cst-unicode-marker-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-marker-conc-of-tree-fix-cst (equal (cst-unicode-marker-conc (abnf::tree-fix abnf::cst)) (cst-unicode-marker-conc abnf::cst)))
Theorem:
(defthm cst-unicode-marker-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-marker-conc abnf::cst) (cst-unicode-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-raw-input-character-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "raw-input-character"))) (let ((__function__ 'cst-raw-input-character-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-raw-input-character-conc (b* ((abnf::cstss (cst-raw-input-character-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-raw-input-character-conc-match (implies (cst-matchp abnf::cst "raw-input-character") (b* ((abnf::cstss (cst-raw-input-character-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF"))) :rule-classes :rewrite)
Theorem:
(defthm cst-raw-input-character-conc-of-tree-fix-cst (equal (cst-raw-input-character-conc (abnf::tree-fix abnf::cst)) (cst-raw-input-character-conc abnf::cst)))
Theorem:
(defthm cst-raw-input-character-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-raw-input-character-conc abnf::cst) (cst-raw-input-character-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-character-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "input-character"))) (let ((__function__ 'cst-input-character-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-input-character-conc (b* ((abnf::cstss (cst-input-character-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-match (implies (cst-matchp abnf::cst "input-character") (b* ((abnf::cstss (cst-input-character-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unicode-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-of-tree-fix-cst (equal (cst-input-character-conc (abnf::tree-fix abnf::cst)) (cst-input-character-conc abnf::cst)))
Theorem:
(defthm cst-input-character-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-character-conc abnf::cst) (cst-input-character-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "input"))) (let ((__function__ 'cst-input-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-input-conc (b* ((abnf::cstss (cst-input-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-conc-match (implies (cst-matchp abnf::cst "input") (b* ((abnf::cstss (cst-input-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*input-element [ sub ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-conc-of-tree-fix-cst (equal (cst-input-conc (abnf::tree-fix abnf::cst)) (cst-input-conc abnf::cst)))
Theorem:
(defthm cst-input-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-conc abnf::cst) (cst-input-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)))) (let ((__function__ 'cst-input-element-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-input-element-conc1 (b* ((abnf::cstss (cst-input-element-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-input-element-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-of-tree-fix-cst (equal (cst-input-element-conc1 (abnf::tree-fix abnf::cst)) (cst-input-element-conc1 abnf::cst)))
Theorem:
(defthm cst-input-element-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc1 abnf::cst) (cst-input-element-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)))) (let ((__function__ 'cst-input-element-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-input-element-conc2 (b* ((abnf::cstss (cst-input-element-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-input-element-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-of-tree-fix-cst (equal (cst-input-element-conc2 (abnf::tree-fix abnf::cst)) (cst-input-element-conc2 abnf::cst)))
Theorem:
(defthm cst-input-element-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc2 abnf::cst) (cst-input-element-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)))) (let ((__function__ 'cst-input-element-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-input-element-conc3 (b* ((abnf::cstss (cst-input-element-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-input-element-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-of-tree-fix-cst (equal (cst-input-element-conc3 (abnf::tree-fix abnf::cst)) (cst-input-element-conc3 abnf::cst)))
Theorem:
(defthm cst-input-element-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc3 abnf::cst) (cst-input-element-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc1 (b* ((abnf::cstss (cst-token-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-token-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-of-tree-fix-cst (equal (cst-token-conc1 (abnf::tree-fix abnf::cst)) (cst-token-conc1 abnf::cst)))
Theorem:
(defthm cst-token-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc1 abnf::cst) (cst-token-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)))) (let ((__function__ 'cst-token-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc2 (b* ((abnf::cstss (cst-token-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-token-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "keyword"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-of-tree-fix-cst (equal (cst-token-conc2 (abnf::tree-fix abnf::cst)) (cst-token-conc2 abnf::cst)))
Theorem:
(defthm cst-token-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc2 abnf::cst) (cst-token-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)))) (let ((__function__ 'cst-token-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc3 (b* ((abnf::cstss (cst-token-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-token-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-of-tree-fix-cst (equal (cst-token-conc3 (abnf::tree-fix abnf::cst)) (cst-token-conc3 abnf::cst)))
Theorem:
(defthm cst-token-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc3 abnf::cst) (cst-token-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)))) (let ((__function__ 'cst-token-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc4 (b* ((abnf::cstss (cst-token-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-token-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "separator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-of-tree-fix-cst (equal (cst-token-conc4 (abnf::tree-fix abnf::cst)) (cst-token-conc4 abnf::cst)))
Theorem:
(defthm cst-token-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4 abnf::cst) (cst-token-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc5 (b* ((abnf::cstss (cst-token-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-token-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "operator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-of-tree-fix-cst (equal (cst-token-conc5 (abnf::tree-fix abnf::cst)) (cst-token-conc5 abnf::cst)))
Theorem:
(defthm cst-token-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5 abnf::cst) (cst-token-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-sub-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "sub"))) (let ((__function__ 'cst-sub-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-sub-conc (b* ((abnf::cstss (cst-sub-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-sub-conc-match (implies (cst-matchp abnf::cst "sub") (b* ((abnf::cstss (cst-sub-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%d26"))) :rule-classes :rewrite)
Theorem:
(defthm cst-sub-conc-of-tree-fix-cst (equal (cst-sub-conc (abnf::tree-fix abnf::cst)) (cst-sub-conc abnf::cst)))
Theorem:
(defthm cst-sub-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-sub-conc abnf::cst) (cst-sub-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-comment-conc1 (b* ((abnf::cstss (cst-comment-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-comment-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "traditional-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-of-tree-fix-cst (equal (cst-comment-conc1 (abnf::tree-fix abnf::cst)) (cst-comment-conc1 abnf::cst)))
Theorem:
(defthm cst-comment-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc1 abnf::cst) (cst-comment-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)))) (let ((__function__ 'cst-comment-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-comment-conc2 (b* ((abnf::cstss (cst-comment-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-comment-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "end-of-line-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-of-tree-fix-cst (equal (cst-comment-conc2 (abnf::tree-fix abnf::cst)) (cst-comment-conc2 abnf::cst)))
Theorem:
(defthm cst-comment-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc2 abnf::cst) (cst-comment-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-traditional-comment-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "traditional-comment"))) (let ((__function__ 'cst-traditional-comment-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-traditional-comment-conc (b* ((abnf::cstss (cst-traditional-comment-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-traditional-comment-conc-match (implies (cst-matchp abnf::cst "traditional-comment") (b* ((abnf::cstss (cst-traditional-comment-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"/\" \"*\" comment-tail"))) :rule-classes :rewrite)
Theorem:
(defthm cst-traditional-comment-conc-of-tree-fix-cst (equal (cst-traditional-comment-conc (abnf::tree-fix abnf::cst)) (cst-traditional-comment-conc abnf::cst)))
Theorem:
(defthm cst-traditional-comment-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-traditional-comment-conc abnf::cst) (cst-traditional-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-not-star-conc1 (b* ((abnf::cstss (cst-not-star-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-not-star-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-of-tree-fix-cst (equal (cst-not-star-conc1 (abnf::tree-fix abnf::cst)) (cst-not-star-conc1 abnf::cst)))
Theorem:
(defthm cst-not-star-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc1 abnf::cst) (cst-not-star-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-not-star-conc2 (b* ((abnf::cstss (cst-not-star-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-not-star-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-of-tree-fix-cst (equal (cst-not-star-conc2 (abnf::tree-fix abnf::cst)) (cst-not-star-conc2 abnf::cst)))
Theorem:
(defthm cst-not-star-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc2 abnf::cst) (cst-not-star-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-not-slash-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-not-star-not-slash-conc1 (b* ((abnf::cstss (cst-not-star-not-slash-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-not-star-not-slash-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-of-tree-fix-cst (equal (cst-not-star-not-slash-conc1 (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc1 abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc1 abnf::cst) (cst-not-star-not-slash-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-not-slash-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-not-star-not-slash-conc2 (b* ((abnf::cstss (cst-not-star-not-slash-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-not-star-not-slash-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-of-tree-fix-cst (equal (cst-not-star-not-slash-conc2 (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc2 abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc2 abnf::cst) (cst-not-star-not-slash-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-end-of-line-comment-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "end-of-line-comment"))) (let ((__function__ 'cst-end-of-line-comment-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-end-of-line-comment-conc (b* ((abnf::cstss (cst-end-of-line-comment-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-end-of-line-comment-conc-match (implies (cst-matchp abnf::cst "end-of-line-comment") (b* ((abnf::cstss (cst-end-of-line-comment-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"/\" \"/\" *input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-end-of-line-comment-conc-of-tree-fix-cst (equal (cst-end-of-line-comment-conc (abnf::tree-fix abnf::cst)) (cst-end-of-line-comment-conc abnf::cst)))
Theorem:
(defthm cst-end-of-line-comment-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-end-of-line-comment-conc abnf::cst) (cst-end-of-line-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier"))) (let ((__function__ 'cst-identifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-identifier-conc (b* ((abnf::cstss (cst-identifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-match (implies (cst-matchp abnf::cst "identifier") (b* ((abnf::cstss (cst-identifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier-chars"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-of-tree-fix-cst (equal (cst-identifier-conc (abnf::tree-fix abnf::cst)) (cst-identifier-conc abnf::cst)))
Theorem:
(defthm cst-identifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-conc abnf::cst) (cst-identifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-chars-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-chars"))) (let ((__function__ 'cst-identifier-chars-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-identifier-chars-conc (b* ((abnf::cstss (cst-identifier-chars-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-chars-conc-match (implies (cst-matchp abnf::cst "identifier-chars") (b* ((abnf::cstss (cst-identifier-chars-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "java-letter *java-letter-or-digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-chars-conc-of-tree-fix-cst (equal (cst-identifier-chars-conc (abnf::tree-fix abnf::cst)) (cst-identifier-chars-conc abnf::cst)))
Theorem:
(defthm cst-identifier-chars-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-chars-conc abnf::cst) (cst-identifier-chars-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter"))) (let ((__function__ 'cst-java-letter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-java-letter-conc (b* ((abnf::cstss (cst-java-letter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-match (implies (cst-matchp abnf::cst "java-letter") (b* ((abnf::cstss (cst-java-letter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-of-tree-fix-cst (equal (cst-java-letter-conc (abnf::tree-fix abnf::cst)) (cst-java-letter-conc abnf::cst)))
Theorem:
(defthm cst-java-letter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-conc abnf::cst) (cst-java-letter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-or-digit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit"))) (let ((__function__ 'cst-java-letter-or-digit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-java-letter-or-digit-conc (b* ((abnf::cstss (cst-java-letter-or-digit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-match (implies (cst-matchp abnf::cst "java-letter-or-digit") (b* ((abnf::cstss (cst-java-letter-or-digit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-of-tree-fix-cst (equal (cst-java-letter-or-digit-conc (abnf::tree-fix abnf::cst)) (cst-java-letter-or-digit-conc abnf::cst)))
Theorem:
(defthm cst-java-letter-or-digit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-or-digit-conc abnf::cst) (cst-java-letter-or-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-identifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-identifier"))) (let ((__function__ 'cst-type-identifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-identifier-conc (b* ((abnf::cstss (cst-type-identifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-match (implies (cst-matchp abnf::cst "type-identifier") (b* ((abnf::cstss (cst-type-identifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-of-tree-fix-cst (equal (cst-type-identifier-conc (abnf::tree-fix abnf::cst)) (cst-type-identifier-conc abnf::cst)))
Theorem:
(defthm cst-type-identifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-identifier-conc abnf::cst) (cst-type-identifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unqualified-method-identifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unqualified-method-identifier"))) (let ((__function__ 'cst-unqualified-method-identifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unqualified-method-identifier-conc (b* ((abnf::cstss (cst-unqualified-method-identifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-match (implies (cst-matchp abnf::cst "unqualified-method-identifier") (b* ((abnf::cstss (cst-unqualified-method-identifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-of-tree-fix-cst (equal (cst-unqualified-method-identifier-conc (abnf::tree-fix abnf::cst)) (cst-unqualified-method-identifier-conc abnf::cst)))
Theorem:
(defthm cst-unqualified-method-identifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unqualified-method-identifier-conc abnf::cst) (cst-unqualified-method-identifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-literal-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc1 (b* ((abnf::cstss (cst-literal-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-literal-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-of-tree-fix-cst (equal (cst-literal-conc1 (abnf::tree-fix abnf::cst)) (cst-literal-conc1 abnf::cst)))
Theorem:
(defthm cst-literal-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc1 abnf::cst) (cst-literal-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-literal-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc2 (b* ((abnf::cstss (cst-literal-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-literal-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-of-tree-fix-cst (equal (cst-literal-conc2 (abnf::tree-fix abnf::cst)) (cst-literal-conc2 abnf::cst)))
Theorem:
(defthm cst-literal-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc2 abnf::cst) (cst-literal-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-literal-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc3 (b* ((abnf::cstss (cst-literal-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-literal-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "boolean-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-of-tree-fix-cst (equal (cst-literal-conc3 (abnf::tree-fix abnf::cst)) (cst-literal-conc3 abnf::cst)))
Theorem:
(defthm cst-literal-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc3 abnf::cst) (cst-literal-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-literal-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc4 (b* ((abnf::cstss (cst-literal-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-literal-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "character-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-of-tree-fix-cst (equal (cst-literal-conc4 (abnf::tree-fix abnf::cst)) (cst-literal-conc4 abnf::cst)))
Theorem:
(defthm cst-literal-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc4 abnf::cst) (cst-literal-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)))) (let ((__function__ 'cst-literal-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc5 (b* ((abnf::cstss (cst-literal-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-literal-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-of-tree-fix-cst (equal (cst-literal-conc5 (abnf::tree-fix abnf::cst)) (cst-literal-conc5 abnf::cst)))
Theorem:
(defthm cst-literal-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc5 abnf::cst) (cst-literal-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc6 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)))) (let ((__function__ 'cst-literal-conc6)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-literal-conc6 (b* ((abnf::cstss (cst-literal-conc6 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)) (b* ((abnf::cstss (cst-literal-conc6 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "null-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-of-tree-fix-cst (equal (cst-literal-conc6 (abnf::tree-fix abnf::cst)) (cst-literal-conc6 abnf::cst)))
Theorem:
(defthm cst-literal-conc6-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc6 abnf::cst) (cst-literal-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-integer-literal-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-integer-literal-conc1 (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "decimal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-of-tree-fix-cst (equal (cst-integer-literal-conc1 (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc1 abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc1 abnf::cst) (cst-integer-literal-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-integer-literal-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-integer-literal-conc2 (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hex-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-of-tree-fix-cst (equal (cst-integer-literal-conc2 (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc2 abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc2 abnf::cst) (cst-integer-literal-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-integer-literal-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-integer-literal-conc3 (b* ((abnf::cstss (cst-integer-literal-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-integer-literal-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-of-tree-fix-cst (equal (cst-integer-literal-conc3 (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc3 abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc3 abnf::cst) (cst-integer-literal-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-integer-literal-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-integer-literal-conc4 (b* ((abnf::cstss (cst-integer-literal-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-integer-literal-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "binary-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-of-tree-fix-cst (equal (cst-integer-literal-conc4 (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc4 abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc4 abnf::cst) (cst-integer-literal-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-decimal-integer-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "decimal-integer-literal"))) (let ((__function__ 'cst-decimal-integer-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-decimal-integer-literal-conc (b* ((abnf::cstss (cst-decimal-integer-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-decimal-integer-literal-conc-match (implies (cst-matchp abnf::cst "decimal-integer-literal") (b* ((abnf::cstss (cst-decimal-integer-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "decimal-numeral [ integer-type-suffix ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-decimal-integer-literal-conc-of-tree-fix-cst (equal (cst-decimal-integer-literal-conc (abnf::tree-fix abnf::cst)) (cst-decimal-integer-literal-conc abnf::cst)))
Theorem:
(defthm cst-decimal-integer-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-decimal-integer-literal-conc abnf::cst) (cst-decimal-integer-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hex-integer-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hex-integer-literal"))) (let ((__function__ 'cst-hex-integer-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-hex-integer-literal-conc (b* ((abnf::cstss (cst-hex-integer-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-integer-literal-conc-match (implies (cst-matchp abnf::cst "hex-integer-literal") (b* ((abnf::cstss (cst-hex-integer-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hex-numeral [ integer-type-suffix ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-integer-literal-conc-of-tree-fix-cst (equal (cst-hex-integer-literal-conc (abnf::tree-fix abnf::cst)) (cst-hex-integer-literal-conc abnf::cst)))
Theorem:
(defthm cst-hex-integer-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hex-integer-literal-conc abnf::cst) (cst-hex-integer-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-octal-integer-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "octal-integer-literal"))) (let ((__function__ 'cst-octal-integer-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-octal-integer-literal-conc (b* ((abnf::cstss (cst-octal-integer-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-integer-literal-conc-match (implies (cst-matchp abnf::cst "octal-integer-literal") (b* ((abnf::cstss (cst-octal-integer-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "octal-numeral [ integer-type-suffix ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-integer-literal-conc-of-tree-fix-cst (equal (cst-octal-integer-literal-conc (abnf::tree-fix abnf::cst)) (cst-octal-integer-literal-conc abnf::cst)))
Theorem:
(defthm cst-octal-integer-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-octal-integer-literal-conc abnf::cst) (cst-octal-integer-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-integer-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-integer-literal"))) (let ((__function__ 'cst-binary-integer-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-integer-literal-conc (b* ((abnf::cstss (cst-binary-integer-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-integer-literal-conc-match (implies (cst-matchp abnf::cst "binary-integer-literal") (b* ((abnf::cstss (cst-binary-integer-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "binary-numeral [ integer-type-suffix ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-integer-literal-conc-of-tree-fix-cst (equal (cst-binary-integer-literal-conc (abnf::tree-fix abnf::cst)) (cst-binary-integer-literal-conc abnf::cst)))
Theorem:
(defthm cst-binary-integer-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-integer-literal-conc abnf::cst) (cst-binary-integer-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-type-suffix-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "integer-type-suffix"))) (let ((__function__ 'cst-integer-type-suffix-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-integer-type-suffix-conc (b* ((abnf::cstss (cst-integer-type-suffix-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-type-suffix-conc-match (implies (cst-matchp abnf::cst "integer-type-suffix") (b* ((abnf::cstss (cst-integer-type-suffix-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"l\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-type-suffix-conc-of-tree-fix-cst (equal (cst-integer-type-suffix-conc (abnf::tree-fix abnf::cst)) (cst-integer-type-suffix-conc abnf::cst)))
Theorem:
(defthm cst-integer-type-suffix-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-type-suffix-conc abnf::cst) (cst-integer-type-suffix-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-digits-and-underscores-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "digits-and-underscores"))) (let ((__function__ 'cst-digits-and-underscores-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-digits-and-underscores-conc (b* ((abnf::cstss (cst-digits-and-underscores-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-digits-and-underscores-conc-match (implies (cst-matchp abnf::cst "digits-and-underscores") (b* ((abnf::cstss (cst-digits-and-underscores-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit-or-underscore *digit-or-underscore"))) :rule-classes :rewrite)
Theorem:
(defthm cst-digits-and-underscores-conc-of-tree-fix-cst (equal (cst-digits-and-underscores-conc (abnf::tree-fix abnf::cst)) (cst-digits-and-underscores-conc abnf::cst)))
Theorem:
(defthm cst-digits-and-underscores-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-digits-and-underscores-conc abnf::cst) (cst-digits-and-underscores-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-underscores-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "underscores"))) (let ((__function__ 'cst-underscores-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-underscores-conc (b* ((abnf::cstss (cst-underscores-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-underscores-conc-match (implies (cst-matchp abnf::cst "underscores") (b* ((abnf::cstss (cst-underscores-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*\"_\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-underscores-conc-of-tree-fix-cst (equal (cst-underscores-conc (abnf::tree-fix abnf::cst)) (cst-underscores-conc abnf::cst)))
Theorem:
(defthm cst-underscores-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-underscores-conc abnf::cst) (cst-underscores-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hex-numeral-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hex-numeral"))) (let ((__function__ 'cst-hex-numeral-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-hex-numeral-conc (b* ((abnf::cstss (cst-hex-numeral-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-numeral-conc-match (implies (cst-matchp abnf::cst "hex-numeral") (b* ((abnf::cstss (cst-hex-numeral-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"0x\" hex-digits"))) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-numeral-conc-of-tree-fix-cst (equal (cst-hex-numeral-conc (abnf::tree-fix abnf::cst)) (cst-hex-numeral-conc abnf::cst)))
Theorem:
(defthm cst-hex-numeral-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hex-numeral-conc abnf::cst) (cst-hex-numeral-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hex-digits-and-underscores-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hex-digits-and-underscores"))) (let ((__function__ 'cst-hex-digits-and-underscores-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-hex-digits-and-underscores-conc (b* ((abnf::cstss (cst-hex-digits-and-underscores-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-digits-and-underscores-conc-match (implies (cst-matchp abnf::cst "hex-digits-and-underscores") (b* ((abnf::cstss (cst-hex-digits-and-underscores-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*hex-digit-or-underscore"))) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-digits-and-underscores-conc-of-tree-fix-cst (equal (cst-hex-digits-and-underscores-conc (abnf::tree-fix abnf::cst)) (cst-hex-digits-and-underscores-conc abnf::cst)))
Theorem:
(defthm cst-hex-digits-and-underscores-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hex-digits-and-underscores-conc abnf::cst) (cst-hex-digits-and-underscores-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-octal-digits-and-underscores-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "octal-digits-and-underscores"))) (let ((__function__ 'cst-octal-digits-and-underscores-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-octal-digits-and-underscores-conc (b* ((abnf::cstss (cst-octal-digits-and-underscores-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digits-and-underscores-conc-match (implies (cst-matchp abnf::cst "octal-digits-and-underscores") (b* ((abnf::cstss (cst-octal-digits-and-underscores-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*octal-digit-or-underscore"))) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digits-and-underscores-conc-of-tree-fix-cst (equal (cst-octal-digits-and-underscores-conc (abnf::tree-fix abnf::cst)) (cst-octal-digits-and-underscores-conc abnf::cst)))
Theorem:
(defthm cst-octal-digits-and-underscores-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-octal-digits-and-underscores-conc abnf::cst) (cst-octal-digits-and-underscores-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-numeral-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-numeral"))) (let ((__function__ 'cst-binary-numeral-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-numeral-conc (b* ((abnf::cstss (cst-binary-numeral-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-numeral-conc-match (implies (cst-matchp abnf::cst "binary-numeral") (b* ((abnf::cstss (cst-binary-numeral-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"0b\" binary-digits"))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-numeral-conc-of-tree-fix-cst (equal (cst-binary-numeral-conc (abnf::tree-fix abnf::cst)) (cst-binary-numeral-conc abnf::cst)))
Theorem:
(defthm cst-binary-numeral-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-numeral-conc abnf::cst) (cst-binary-numeral-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-digits-and-underscores-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-digits-and-underscores"))) (let ((__function__ 'cst-binary-digits-and-underscores-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-digits-and-underscores-conc (b* ((abnf::cstss (cst-binary-digits-and-underscores-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-digits-and-underscores-conc-match (implies (cst-matchp abnf::cst "binary-digits-and-underscores") (b* ((abnf::cstss (cst-binary-digits-and-underscores-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*binary-digit-or-underscore"))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-digits-and-underscores-conc-of-tree-fix-cst (equal (cst-binary-digits-and-underscores-conc (abnf::tree-fix abnf::cst)) (cst-binary-digits-and-underscores-conc abnf::cst)))
Theorem:
(defthm cst-binary-digits-and-underscores-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-digits-and-underscores-conc abnf::cst) (cst-binary-digits-and-underscores-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-point-literal-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-floating-point-literal-conc1 (b* ((abnf::cstss (cst-floating-point-literal-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-floating-point-literal-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "decimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-of-tree-fix-cst (equal (cst-floating-point-literal-conc1 (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc1 abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc1 abnf::cst) (cst-floating-point-literal-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-point-literal-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-floating-point-literal-conc2 (b* ((abnf::cstss (cst-floating-point-literal-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-floating-point-literal-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-of-tree-fix-cst (equal (cst-floating-point-literal-conc2 (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc2 abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc2 abnf::cst) (cst-floating-point-literal-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exponent-part-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exponent-part"))) (let ((__function__ 'cst-exponent-part-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exponent-part-conc (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-part-conc-match (implies (cst-matchp abnf::cst "exponent-part") (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "exponent-indicator signed-integer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-part-conc-of-tree-fix-cst (equal (cst-exponent-part-conc (abnf::tree-fix abnf::cst)) (cst-exponent-part-conc abnf::cst)))
Theorem:
(defthm cst-exponent-part-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exponent-part-conc abnf::cst) (cst-exponent-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exponent-indicator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exponent-indicator"))) (let ((__function__ 'cst-exponent-indicator-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exponent-indicator-conc (b* ((abnf::cstss (cst-exponent-indicator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-indicator-conc-match (implies (cst-matchp abnf::cst "exponent-indicator") (b* ((abnf::cstss (cst-exponent-indicator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"e\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-indicator-conc-of-tree-fix-cst (equal (cst-exponent-indicator-conc (abnf::tree-fix abnf::cst)) (cst-exponent-indicator-conc abnf::cst)))
Theorem:
(defthm cst-exponent-indicator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exponent-indicator-conc abnf::cst) (cst-exponent-indicator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-signed-integer-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "signed-integer"))) (let ((__function__ 'cst-signed-integer-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-signed-integer-conc (b* ((abnf::cstss (cst-signed-integer-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-signed-integer-conc-match (implies (cst-matchp abnf::cst "signed-integer") (b* ((abnf::cstss (cst-signed-integer-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ sign ] digits"))) :rule-classes :rewrite)
Theorem:
(defthm cst-signed-integer-conc-of-tree-fix-cst (equal (cst-signed-integer-conc (abnf::tree-fix abnf::cst)) (cst-signed-integer-conc abnf::cst)))
Theorem:
(defthm cst-signed-integer-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-signed-integer-conc abnf::cst) (cst-signed-integer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hexadecimal-floating-point-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hexadecimal-floating-point-literal"))) (let ((__function__ 'cst-hexadecimal-floating-point-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-hexadecimal-floating-point-literal-conc (b* ((abnf::cstss (cst-hexadecimal-floating-point-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-floating-point-literal-conc-match (implies (cst-matchp abnf::cst "hexadecimal-floating-point-literal") (b* ((abnf::cstss (cst-hexadecimal-floating-point-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hex-significand binary-exponent [ float-type-suffix ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-floating-point-literal-conc-of-tree-fix-cst (equal (cst-hexadecimal-floating-point-literal-conc (abnf::tree-fix abnf::cst)) (cst-hexadecimal-floating-point-literal-conc abnf::cst)))
Theorem:
(defthm cst-hexadecimal-floating-point-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hexadecimal-floating-point-literal-conc abnf::cst) (cst-hexadecimal-floating-point-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-exponent-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-exponent"))) (let ((__function__ 'cst-binary-exponent-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-exponent-conc (b* ((abnf::cstss (cst-binary-exponent-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-conc-match (implies (cst-matchp abnf::cst "binary-exponent") (b* ((abnf::cstss (cst-binary-exponent-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "binary-exponent-indicator signed-integer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-conc-of-tree-fix-cst (equal (cst-binary-exponent-conc (abnf::tree-fix abnf::cst)) (cst-binary-exponent-conc abnf::cst)))
Theorem:
(defthm cst-binary-exponent-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-exponent-conc abnf::cst) (cst-binary-exponent-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-exponent-indicator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-exponent-indicator"))) (let ((__function__ 'cst-binary-exponent-indicator-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-exponent-indicator-conc (b* ((abnf::cstss (cst-binary-exponent-indicator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-indicator-conc-match (implies (cst-matchp abnf::cst "binary-exponent-indicator") (b* ((abnf::cstss (cst-binary-exponent-indicator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"p\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-indicator-conc-of-tree-fix-cst (equal (cst-binary-exponent-indicator-conc (abnf::tree-fix abnf::cst)) (cst-binary-exponent-indicator-conc abnf::cst)))
Theorem:
(defthm cst-binary-exponent-indicator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-exponent-indicator-conc abnf::cst) (cst-binary-exponent-indicator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-character-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-character"))) (let ((__function__ 'cst-single-character-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-single-character-conc (b* ((abnf::cstss (cst-single-character-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-match (implies (cst-matchp abnf::cst "single-character") (b* ((abnf::cstss (cst-single-character-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-of-tree-fix-cst (equal (cst-single-character-conc (abnf::tree-fix abnf::cst)) (cst-single-character-conc abnf::cst)))
Theorem:
(defthm cst-single-character-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-character-conc abnf::cst) (cst-single-character-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "string-literal"))) (let ((__function__ 'cst-string-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-string-literal-conc (b* ((abnf::cstss (cst-string-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-literal-conc-match (implies (cst-matchp abnf::cst "string-literal") (b* ((abnf::cstss (cst-string-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%d34 *string-character %d34"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-literal-conc-of-tree-fix-cst (equal (cst-string-literal-conc (abnf::tree-fix abnf::cst)) (cst-string-literal-conc abnf::cst)))
Theorem:
(defthm cst-string-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-literal-conc abnf::cst) (cst-string-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-string-character-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-string-character-conc1 (b* ((abnf::cstss (cst-string-character-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-string-character-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-of-tree-fix-cst (equal (cst-string-character-conc1 (abnf::tree-fix abnf::cst)) (cst-string-character-conc1 abnf::cst)))
Theorem:
(defthm cst-string-character-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc1 abnf::cst) (cst-string-character-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-string-character-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-string-character-conc2 (b* ((abnf::cstss (cst-string-character-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-string-character-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-of-tree-fix-cst (equal (cst-string-character-conc2 (abnf::tree-fix abnf::cst)) (cst-string-character-conc2 abnf::cst)))
Theorem:
(defthm cst-string-character-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc2 abnf::cst) (cst-string-character-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-null-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "null-literal"))) (let ((__function__ 'cst-null-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-null-literal-conc (b* ((abnf::cstss (cst-null-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-null-literal-conc-match (implies (cst-matchp abnf::cst "null-literal") (b* ((abnf::cstss (cst-null-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"null\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-null-literal-conc-of-tree-fix-cst (equal (cst-null-literal-conc (abnf::tree-fix abnf::cst)) (cst-null-literal-conc abnf::cst)))
Theorem:
(defthm cst-null-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-null-literal-conc abnf::cst) (cst-null-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-conc1 (b* ((abnf::cstss (cst-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-of-tree-fix-cst (equal (cst-type-conc1 (abnf::tree-fix abnf::cst)) (cst-type-conc1 abnf::cst)))
Theorem:
(defthm cst-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc1 abnf::cst) (cst-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-conc2 (b* ((abnf::cstss (cst-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-of-tree-fix-cst (equal (cst-type-conc2 (abnf::tree-fix abnf::cst)) (cst-type-conc2 abnf::cst)))
Theorem:
(defthm cst-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc2 abnf::cst) (cst-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-numeric-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-numeric-type-conc1 (b* ((abnf::cstss (cst-numeric-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-numeric-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "integral-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-of-tree-fix-cst (equal (cst-numeric-type-conc1 (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc1 abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc1 abnf::cst) (cst-numeric-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-numeric-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-numeric-type-conc2 (b* ((abnf::cstss (cst-numeric-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-numeric-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "floating-point-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-of-tree-fix-cst (equal (cst-numeric-type-conc2 (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc2 abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc2 abnf::cst) (cst-numeric-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-reference-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-reference-type-conc1 (b* ((abnf::cstss (cst-reference-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-reference-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-of-tree-fix-cst (equal (cst-reference-type-conc1 (abnf::tree-fix abnf::cst)) (cst-reference-type-conc1 abnf::cst)))
Theorem:
(defthm cst-reference-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc1 abnf::cst) (cst-reference-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-reference-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-reference-type-conc2 (b* ((abnf::cstss (cst-reference-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-reference-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-of-tree-fix-cst (equal (cst-reference-type-conc2 (abnf::tree-fix abnf::cst)) (cst-reference-type-conc2 abnf::cst)))
Theorem:
(defthm cst-reference-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc2 abnf::cst) (cst-reference-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-reference-type-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-reference-type-conc3 (b* ((abnf::cstss (cst-reference-type-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-reference-type-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-of-tree-fix-cst (equal (cst-reference-type-conc3 (abnf::tree-fix abnf::cst)) (cst-reference-type-conc3 abnf::cst)))
Theorem:
(defthm cst-reference-type-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc3 abnf::cst) (cst-reference-type-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-or-interface-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-or-interface-type-conc1 (b* ((abnf::cstss (cst-class-or-interface-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-class-or-interface-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-of-tree-fix-cst (equal (cst-class-or-interface-type-conc1 (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc1 abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc1 abnf::cst) (cst-class-or-interface-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-or-interface-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-or-interface-type-conc2 (b* ((abnf::cstss (cst-class-or-interface-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-class-or-interface-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-of-tree-fix-cst (equal (cst-class-or-interface-type-conc2 (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc2 abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc2 abnf::cst) (cst-class-or-interface-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-type-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-type"))) (let ((__function__ 'cst-interface-type-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-type-conc (b* ((abnf::cstss (cst-interface-type-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-match (implies (cst-matchp abnf::cst "interface-type") (b* ((abnf::cstss (cst-interface-type-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-of-tree-fix-cst (equal (cst-interface-type-conc (abnf::tree-fix abnf::cst)) (cst-interface-type-conc abnf::cst)))
Theorem:
(defthm cst-interface-type-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-type-conc abnf::cst) (cst-interface-type-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-variable-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-variable"))) (let ((__function__ 'cst-type-variable-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-variable-conc (b* ((abnf::cstss (cst-type-variable-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-variable-conc-match (implies (cst-matchp abnf::cst "type-variable") (b* ((abnf::cstss (cst-type-variable-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-variable-conc-of-tree-fix-cst (equal (cst-type-variable-conc (abnf::tree-fix abnf::cst)) (cst-type-variable-conc abnf::cst)))
Theorem:
(defthm cst-type-variable-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-variable-conc abnf::cst) (cst-type-variable-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-dims-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "dims"))) (let ((__function__ 'cst-dims-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-dims-conc (b* ((abnf::cstss (cst-dims-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-dims-conc-match (implies (cst-matchp abnf::cst "dims") (b* ((abnf::cstss (cst-dims-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*( *annotation \"[\" \"]\" )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-dims-conc-of-tree-fix-cst (equal (cst-dims-conc (abnf::tree-fix abnf::cst)) (cst-dims-conc abnf::cst)))
Theorem:
(defthm cst-dims-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-dims-conc abnf::cst) (cst-dims-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameter"))) (let ((__function__ 'cst-type-parameter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-parameter-conc (b* ((abnf::cstss (cst-type-parameter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-conc-match (implies (cst-matchp abnf::cst "type-parameter") (b* ((abnf::cstss (cst-type-parameter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*type-parameter-modifier type-identifier [ type-bound ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-conc-of-tree-fix-cst (equal (cst-type-parameter-conc (abnf::tree-fix abnf::cst)) (cst-type-parameter-conc abnf::cst)))
Theorem:
(defthm cst-type-parameter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameter-conc abnf::cst) (cst-type-parameter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameter-modifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier"))) (let ((__function__ 'cst-type-parameter-modifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-parameter-modifier-conc (b* ((abnf::cstss (cst-type-parameter-modifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-match (implies (cst-matchp abnf::cst "type-parameter-modifier") (b* ((abnf::cstss (cst-type-parameter-modifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-of-tree-fix-cst (equal (cst-type-parameter-modifier-conc (abnf::tree-fix abnf::cst)) (cst-type-parameter-modifier-conc abnf::cst)))
Theorem:
(defthm cst-type-parameter-modifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameter-modifier-conc abnf::cst) (cst-type-parameter-modifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-additional-bound-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "additional-bound"))) (let ((__function__ 'cst-additional-bound-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-additional-bound-conc (b* ((abnf::cstss (cst-additional-bound-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-additional-bound-conc-match (implies (cst-matchp abnf::cst "additional-bound") (b* ((abnf::cstss (cst-additional-bound-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"&\" interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-additional-bound-conc-of-tree-fix-cst (equal (cst-additional-bound-conc (abnf::tree-fix abnf::cst)) (cst-additional-bound-conc abnf::cst)))
Theorem:
(defthm cst-additional-bound-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-additional-bound-conc abnf::cst) (cst-additional-bound-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-arguments-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-arguments"))) (let ((__function__ 'cst-type-arguments-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-arguments-conc (b* ((abnf::cstss (cst-type-arguments-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-arguments-conc-match (implies (cst-matchp abnf::cst "type-arguments") (b* ((abnf::cstss (cst-type-arguments-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"<\" type-argument-list \">\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-arguments-conc-of-tree-fix-cst (equal (cst-type-arguments-conc (abnf::tree-fix abnf::cst)) (cst-type-arguments-conc abnf::cst)))
Theorem:
(defthm cst-type-arguments-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-arguments-conc abnf::cst) (cst-type-arguments-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-argument-list"))) (let ((__function__ 'cst-type-argument-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-argument-list-conc (b* ((abnf::cstss (cst-type-argument-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-list-conc-match (implies (cst-matchp abnf::cst "type-argument-list") (b* ((abnf::cstss (cst-type-argument-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-argument *( \",\" type-argument )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-list-conc-of-tree-fix-cst (equal (cst-type-argument-list-conc (abnf::tree-fix abnf::cst)) (cst-type-argument-list-conc abnf::cst)))
Theorem:
(defthm cst-type-argument-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-list-conc abnf::cst) (cst-type-argument-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-argument-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-argument-conc1 (b* ((abnf::cstss (cst-type-argument-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-type-argument-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-of-tree-fix-cst (equal (cst-type-argument-conc1 (abnf::tree-fix abnf::cst)) (cst-type-argument-conc1 abnf::cst)))
Theorem:
(defthm cst-type-argument-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc1 abnf::cst) (cst-type-argument-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-argument-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-argument-conc2 (b* ((abnf::cstss (cst-type-argument-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-type-argument-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "wildcard"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-of-tree-fix-cst (equal (cst-type-argument-conc2 (abnf::tree-fix abnf::cst)) (cst-type-argument-conc2 abnf::cst)))
Theorem:
(defthm cst-type-argument-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc2 abnf::cst) (cst-type-argument-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-wildcard-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "wildcard"))) (let ((__function__ 'cst-wildcard-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-wildcard-conc (b* ((abnf::cstss (cst-wildcard-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-wildcard-conc-match (implies (cst-matchp abnf::cst "wildcard") (b* ((abnf::cstss (cst-wildcard-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation \"?\" [ wildcard-bounds ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-wildcard-conc-of-tree-fix-cst (equal (cst-wildcard-conc (abnf::tree-fix abnf::cst)) (cst-wildcard-conc abnf::cst)))
Theorem:
(defthm cst-wildcard-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-wildcard-conc abnf::cst) (cst-wildcard-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-method-name-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "method-name"))) (let ((__function__ 'cst-method-name-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-method-name-conc (b* ((abnf::cstss (cst-method-name-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-match (implies (cst-matchp abnf::cst "method-name") (b* ((abnf::cstss (cst-method-name-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unqualified-method-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-of-tree-fix-cst (equal (cst-method-name-conc (abnf::tree-fix abnf::cst)) (cst-method-name-conc abnf::cst)))
Theorem:
(defthm cst-method-name-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-method-name-conc abnf::cst) (cst-method-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)))) (let ((__function__ 'cst-compilation-unit-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-compilation-unit-conc1 (b* ((abnf::cstss (cst-compilation-unit-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-compilation-unit-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "ordinary-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-of-tree-fix-cst (equal (cst-compilation-unit-conc1 (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc1 abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc1 abnf::cst) (cst-compilation-unit-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)))) (let ((__function__ 'cst-compilation-unit-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-compilation-unit-conc2 (b* ((abnf::cstss (cst-compilation-unit-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-compilation-unit-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "modular-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-of-tree-fix-cst (equal (cst-compilation-unit-conc2 (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc2 abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc2 abnf::cst) (cst-compilation-unit-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-ordinary-compilation-unit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "ordinary-compilation-unit"))) (let ((__function__ 'cst-ordinary-compilation-unit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-ordinary-compilation-unit-conc (b* ((abnf::cstss (cst-ordinary-compilation-unit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-ordinary-compilation-unit-conc-match (implies (cst-matchp abnf::cst "ordinary-compilation-unit") (b* ((abnf::cstss (cst-ordinary-compilation-unit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ package-declaration ] *import-declaration *type-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-ordinary-compilation-unit-conc-of-tree-fix-cst (equal (cst-ordinary-compilation-unit-conc (abnf::tree-fix abnf::cst)) (cst-ordinary-compilation-unit-conc abnf::cst)))
Theorem:
(defthm cst-ordinary-compilation-unit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-ordinary-compilation-unit-conc abnf::cst) (cst-ordinary-compilation-unit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-modular-compilation-unit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "modular-compilation-unit"))) (let ((__function__ 'cst-modular-compilation-unit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-modular-compilation-unit-conc (b* ((abnf::cstss (cst-modular-compilation-unit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-modular-compilation-unit-conc-match (implies (cst-matchp abnf::cst "modular-compilation-unit") (b* ((abnf::cstss (cst-modular-compilation-unit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*import-declaration module-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-modular-compilation-unit-conc-of-tree-fix-cst (equal (cst-modular-compilation-unit-conc (abnf::tree-fix abnf::cst)) (cst-modular-compilation-unit-conc abnf::cst)))
Theorem:
(defthm cst-modular-compilation-unit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-modular-compilation-unit-conc abnf::cst) (cst-modular-compilation-unit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-package-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "package-declaration"))) (let ((__function__ 'cst-package-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-package-declaration-conc (b* ((abnf::cstss (cst-package-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-package-declaration-conc-match (implies (cst-matchp abnf::cst "package-declaration") (b* ((abnf::cstss (cst-package-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-package-declaration-conc-of-tree-fix-cst (equal (cst-package-declaration-conc (abnf::tree-fix abnf::cst)) (cst-package-declaration-conc abnf::cst)))
Theorem:
(defthm cst-package-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-package-declaration-conc abnf::cst) (cst-package-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-package-modifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "package-modifier"))) (let ((__function__ 'cst-package-modifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-package-modifier-conc (b* ((abnf::cstss (cst-package-modifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-match (implies (cst-matchp abnf::cst "package-modifier") (b* ((abnf::cstss (cst-package-modifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-of-tree-fix-cst (equal (cst-package-modifier-conc (abnf::tree-fix abnf::cst)) (cst-package-modifier-conc abnf::cst)))
Theorem:
(defthm cst-package-modifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-package-modifier-conc abnf::cst) (cst-package-modifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-import-declaration-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-import-declaration-conc1 (b* ((abnf::cstss (cst-import-declaration-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-import-declaration-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "single-type-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-of-tree-fix-cst (equal (cst-import-declaration-conc1 (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc1 abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc1 abnf::cst) (cst-import-declaration-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-import-declaration-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-import-declaration-conc2 (b* ((abnf::cstss (cst-import-declaration-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-import-declaration-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-of-tree-fix-cst (equal (cst-import-declaration-conc2 (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc2 abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc2 abnf::cst) (cst-import-declaration-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-import-declaration-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-import-declaration-conc3 (b* ((abnf::cstss (cst-import-declaration-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-import-declaration-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "single-static-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-of-tree-fix-cst (equal (cst-import-declaration-conc3 (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc3 abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc3 abnf::cst) (cst-import-declaration-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-import-declaration-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-import-declaration-conc4 (b* ((abnf::cstss (cst-import-declaration-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-import-declaration-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "static-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-of-tree-fix-cst (equal (cst-import-declaration-conc4 (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc4 abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc4 abnf::cst) (cst-import-declaration-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-type-import-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-type-import-declaration"))) (let ((__function__ 'cst-single-type-import-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-single-type-import-declaration-conc (b* ((abnf::cstss (cst-single-type-import-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-type-import-declaration-conc-match (implies (cst-matchp abnf::cst "single-type-import-declaration") (b* ((abnf::cstss (cst-single-type-import-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"import\" type-name \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-type-import-declaration-conc-of-tree-fix-cst (equal (cst-single-type-import-declaration-conc (abnf::tree-fix abnf::cst)) (cst-single-type-import-declaration-conc abnf::cst)))
Theorem:
(defthm cst-single-type-import-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-type-import-declaration-conc abnf::cst) (cst-single-type-import-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-import-on-demand-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-import-on-demand-declaration"))) (let ((__function__ 'cst-type-import-on-demand-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-import-on-demand-declaration-conc (b* ((abnf::cstss (cst-type-import-on-demand-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-import-on-demand-declaration-conc-match (implies (cst-matchp abnf::cst "type-import-on-demand-declaration") (b* ((abnf::cstss (cst-type-import-on-demand-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"import\" package-or-type-name \".\" \"*\" \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-import-on-demand-declaration-conc-of-tree-fix-cst (equal (cst-type-import-on-demand-declaration-conc (abnf::tree-fix abnf::cst)) (cst-type-import-on-demand-declaration-conc abnf::cst)))
Theorem:
(defthm cst-type-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-import-on-demand-declaration-conc abnf::cst) (cst-type-import-on-demand-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-static-import-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-static-import-declaration"))) (let ((__function__ 'cst-single-static-import-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-single-static-import-declaration-conc (b* ((abnf::cstss (cst-single-static-import-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-static-import-declaration-conc-match (implies (cst-matchp abnf::cst "single-static-import-declaration") (b* ((abnf::cstss (cst-single-static-import-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" identifier \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-static-import-declaration-conc-of-tree-fix-cst (equal (cst-single-static-import-declaration-conc (abnf::tree-fix abnf::cst)) (cst-single-static-import-declaration-conc abnf::cst)))
Theorem:
(defthm cst-single-static-import-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-static-import-declaration-conc abnf::cst) (cst-single-static-import-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-static-import-on-demand-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "static-import-on-demand-declaration"))) (let ((__function__ 'cst-static-import-on-demand-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-static-import-on-demand-declaration-conc (b* ((abnf::cstss (cst-static-import-on-demand-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-static-import-on-demand-declaration-conc-match (implies (cst-matchp abnf::cst "static-import-on-demand-declaration") (b* ((abnf::cstss (cst-static-import-on-demand-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-static-import-on-demand-declaration-conc-of-tree-fix-cst (equal (cst-static-import-on-demand-declaration-conc (abnf::tree-fix abnf::cst)) (cst-static-import-on-demand-declaration-conc abnf::cst)))
Theorem:
(defthm cst-static-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-static-import-on-demand-declaration-conc abnf::cst) (cst-static-import-on-demand-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-module-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "module-declaration"))) (let ((__function__ 'cst-module-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-module-declaration-conc (b* ((abnf::cstss (cst-module-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-module-declaration-conc-match (implies (cst-matchp abnf::cst "module-declaration") (b* ((abnf::cstss (cst-module-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-module-declaration-conc-of-tree-fix-cst (equal (cst-module-declaration-conc (abnf::tree-fix abnf::cst)) (cst-module-declaration-conc abnf::cst)))
Theorem:
(defthm cst-module-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-module-declaration-conc abnf::cst) (cst-module-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-declaration-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-declaration-conc1 (b* ((abnf::cstss (cst-class-declaration-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-class-declaration-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "normal-class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-of-tree-fix-cst (equal (cst-class-declaration-conc1 (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc1 abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc1 abnf::cst) (cst-class-declaration-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-declaration-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-declaration-conc2 (b* ((abnf::cstss (cst-class-declaration-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-class-declaration-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enum-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-of-tree-fix-cst (equal (cst-class-declaration-conc2 (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc2 abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc2 abnf::cst) (cst-class-declaration-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-normal-class-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "normal-class-declaration"))) (let ((__function__ 'cst-normal-class-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-normal-class-declaration-conc (b* ((abnf::cstss (cst-normal-class-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-class-declaration-conc-match (implies (cst-matchp abnf::cst "normal-class-declaration") (b* ((abnf::cstss (cst-normal-class-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ superclass ] [ superinterfaces ] class-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-class-declaration-conc-of-tree-fix-cst (equal (cst-normal-class-declaration-conc (abnf::tree-fix abnf::cst)) (cst-normal-class-declaration-conc abnf::cst)))
Theorem:
(defthm cst-normal-class-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-normal-class-declaration-conc abnf::cst) (cst-normal-class-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameters-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameters"))) (let ((__function__ 'cst-type-parameters-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-parameters-conc (b* ((abnf::cstss (cst-type-parameters-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameters-conc-match (implies (cst-matchp abnf::cst "type-parameters") (b* ((abnf::cstss (cst-type-parameters-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"<\" type-parameter-list \">\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameters-conc-of-tree-fix-cst (equal (cst-type-parameters-conc (abnf::tree-fix abnf::cst)) (cst-type-parameters-conc abnf::cst)))
Theorem:
(defthm cst-type-parameters-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameters-conc abnf::cst) (cst-type-parameters-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameter-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameter-list"))) (let ((__function__ 'cst-type-parameter-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-type-parameter-list-conc (b* ((abnf::cstss (cst-type-parameter-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-list-conc-match (implies (cst-matchp abnf::cst "type-parameter-list") (b* ((abnf::cstss (cst-type-parameter-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-parameter *( \",\" type-parameter )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-list-conc-of-tree-fix-cst (equal (cst-type-parameter-list-conc (abnf::tree-fix abnf::cst)) (cst-type-parameter-list-conc abnf::cst)))
Theorem:
(defthm cst-type-parameter-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameter-list-conc abnf::cst) (cst-type-parameter-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-superclass-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "superclass"))) (let ((__function__ 'cst-superclass-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-superclass-conc (b* ((abnf::cstss (cst-superclass-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-superclass-conc-match (implies (cst-matchp abnf::cst "superclass") (b* ((abnf::cstss (cst-superclass-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-superclass-conc-of-tree-fix-cst (equal (cst-superclass-conc (abnf::tree-fix abnf::cst)) (cst-superclass-conc abnf::cst)))
Theorem:
(defthm cst-superclass-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-superclass-conc abnf::cst) (cst-superclass-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-superinterfaces-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "superinterfaces"))) (let ((__function__ 'cst-superinterfaces-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-superinterfaces-conc (b* ((abnf::cstss (cst-superinterfaces-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-superinterfaces-conc-match (implies (cst-matchp abnf::cst "superinterfaces") (b* ((abnf::cstss (cst-superinterfaces-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"implements\" interface-type-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-superinterfaces-conc-of-tree-fix-cst (equal (cst-superinterfaces-conc (abnf::tree-fix abnf::cst)) (cst-superinterfaces-conc abnf::cst)))
Theorem:
(defthm cst-superinterfaces-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-superinterfaces-conc abnf::cst) (cst-superinterfaces-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-type-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-type-list"))) (let ((__function__ 'cst-interface-type-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-type-list-conc (b* ((abnf::cstss (cst-interface-type-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-list-conc-match (implies (cst-matchp abnf::cst "interface-type-list") (b* ((abnf::cstss (cst-interface-type-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "interface-type *( \",\" interface-type )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-list-conc-of-tree-fix-cst (equal (cst-interface-type-list-conc (abnf::tree-fix abnf::cst)) (cst-interface-type-list-conc abnf::cst)))
Theorem:
(defthm cst-interface-type-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-type-list-conc abnf::cst) (cst-interface-type-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "class-body"))) (let ((__function__ 'cst-class-body-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-body-conc (b* ((abnf::cstss (cst-class-body-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-conc-match (implies (cst-matchp abnf::cst "class-body") (b* ((abnf::cstss (cst-class-body-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" *class-body-declaration \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-conc-of-tree-fix-cst (equal (cst-class-body-conc (abnf::tree-fix abnf::cst)) (cst-class-body-conc abnf::cst)))
Theorem:
(defthm cst-class-body-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-conc abnf::cst) (cst-class-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-body-declaration-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-body-declaration-conc1 (b* ((abnf::cstss (cst-class-body-declaration-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-class-body-declaration-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-member-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-of-tree-fix-cst (equal (cst-class-body-declaration-conc1 (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc1 abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc1 abnf::cst) (cst-class-body-declaration-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-body-declaration-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-body-declaration-conc2 (b* ((abnf::cstss (cst-class-body-declaration-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-class-body-declaration-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "instance-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-of-tree-fix-cst (equal (cst-class-body-declaration-conc2 (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc2 abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc2 abnf::cst) (cst-class-body-declaration-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-class-body-declaration-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-body-declaration-conc3 (b* ((abnf::cstss (cst-class-body-declaration-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-class-body-declaration-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "static-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-of-tree-fix-cst (equal (cst-class-body-declaration-conc3 (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc3 abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc3 abnf::cst) (cst-class-body-declaration-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-class-body-declaration-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-body-declaration-conc4 (b* ((abnf::cstss (cst-class-body-declaration-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-class-body-declaration-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "constructor-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-of-tree-fix-cst (equal (cst-class-body-declaration-conc4 (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc4 abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc4 abnf::cst) (cst-class-body-declaration-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-field-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "field-declaration"))) (let ((__function__ 'cst-field-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-field-declaration-conc (b* ((abnf::cstss (cst-field-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-field-declaration-conc-match (implies (cst-matchp abnf::cst "field-declaration") (b* ((abnf::cstss (cst-field-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*field-modifier unann-type variable-declarator-list \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-field-declaration-conc-of-tree-fix-cst (equal (cst-field-declaration-conc (abnf::tree-fix abnf::cst)) (cst-field-declaration-conc abnf::cst)))
Theorem:
(defthm cst-field-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-field-declaration-conc abnf::cst) (cst-field-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-declarator-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-declarator-list"))) (let ((__function__ 'cst-variable-declarator-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-declarator-list-conc (b* ((abnf::cstss (cst-variable-declarator-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-list-conc-match (implies (cst-matchp abnf::cst "variable-declarator-list") (b* ((abnf::cstss (cst-variable-declarator-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "variable-declarator *( \",\" variable-declarator )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-list-conc-of-tree-fix-cst (equal (cst-variable-declarator-list-conc (abnf::tree-fix abnf::cst)) (cst-variable-declarator-list-conc abnf::cst)))
Theorem:
(defthm cst-variable-declarator-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-declarator-list-conc abnf::cst) (cst-variable-declarator-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-declarator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-declarator"))) (let ((__function__ 'cst-variable-declarator-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-declarator-conc (b* ((abnf::cstss (cst-variable-declarator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-conc-match (implies (cst-matchp abnf::cst "variable-declarator") (b* ((abnf::cstss (cst-variable-declarator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "variable-declarator-id [ \"=\" variable-initializer ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-conc-of-tree-fix-cst (equal (cst-variable-declarator-conc (abnf::tree-fix abnf::cst)) (cst-variable-declarator-conc abnf::cst)))
Theorem:
(defthm cst-variable-declarator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-declarator-conc abnf::cst) (cst-variable-declarator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-declarator-id-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-declarator-id"))) (let ((__function__ 'cst-variable-declarator-id-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-declarator-id-conc (b* ((abnf::cstss (cst-variable-declarator-id-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-id-conc-match (implies (cst-matchp abnf::cst "variable-declarator-id") (b* ((abnf::cstss (cst-variable-declarator-id-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier [ dims ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-declarator-id-conc-of-tree-fix-cst (equal (cst-variable-declarator-id-conc (abnf::tree-fix abnf::cst)) (cst-variable-declarator-id-conc abnf::cst)))
Theorem:
(defthm cst-variable-declarator-id-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-declarator-id-conc abnf::cst) (cst-variable-declarator-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-initializer-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-initializer-conc1 (b* ((abnf::cstss (cst-variable-initializer-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-variable-initializer-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-of-tree-fix-cst (equal (cst-variable-initializer-conc1 (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc1 abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc1 abnf::cst) (cst-variable-initializer-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-initializer-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-initializer-conc2 (b* ((abnf::cstss (cst-variable-initializer-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-variable-initializer-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-of-tree-fix-cst (equal (cst-variable-initializer-conc2 (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc2 abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc2 abnf::cst) (cst-variable-initializer-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-type-conc1 (b* ((abnf::cstss (cst-unann-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-unann-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-of-tree-fix-cst (equal (cst-unann-type-conc1 (abnf::tree-fix abnf::cst)) (cst-unann-type-conc1 abnf::cst)))
Theorem:
(defthm cst-unann-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc1 abnf::cst) (cst-unann-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-type-conc2 (b* ((abnf::cstss (cst-unann-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-unann-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-of-tree-fix-cst (equal (cst-unann-type-conc2 (abnf::tree-fix abnf::cst)) (cst-unann-type-conc2 abnf::cst)))
Theorem:
(defthm cst-unann-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc2 abnf::cst) (cst-unann-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-reference-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-reference-type-conc1 (b* ((abnf::cstss (cst-unann-reference-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-unann-reference-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-of-tree-fix-cst (equal (cst-unann-reference-type-conc1 (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc1 abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc1 abnf::cst) (cst-unann-reference-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-reference-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-reference-type-conc2 (b* ((abnf::cstss (cst-unann-reference-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-unann-reference-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-of-tree-fix-cst (equal (cst-unann-reference-type-conc2 (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc2 abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc2 abnf::cst) (cst-unann-reference-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-unann-reference-type-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-reference-type-conc3 (b* ((abnf::cstss (cst-unann-reference-type-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-unann-reference-type-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-of-tree-fix-cst (equal (cst-unann-reference-type-conc3 (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc3 abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc3 abnf::cst) (cst-unann-reference-type-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-class-or-interface-type-conc1 (b* ((abnf::cstss (cst-unann-class-or-interface-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-unann-class-or-interface-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc1 (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc1 abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc1 abnf::cst) (cst-unann-class-or-interface-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-class-or-interface-type-conc2 (b* ((abnf::cstss (cst-unann-class-or-interface-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-unann-class-or-interface-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc2 (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc2 abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc2 abnf::cst) (cst-unann-class-or-interface-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-interface-type-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-interface-type"))) (let ((__function__ 'cst-unann-interface-type-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-interface-type-conc (b* ((abnf::cstss (cst-unann-interface-type-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-match (implies (cst-matchp abnf::cst "unann-interface-type") (b* ((abnf::cstss (cst-unann-interface-type-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-of-tree-fix-cst (equal (cst-unann-interface-type-conc (abnf::tree-fix abnf::cst)) (cst-unann-interface-type-conc abnf::cst)))
Theorem:
(defthm cst-unann-interface-type-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-interface-type-conc abnf::cst) (cst-unann-interface-type-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-variable-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-type-variable"))) (let ((__function__ 'cst-unann-type-variable-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unann-type-variable-conc (b* ((abnf::cstss (cst-unann-type-variable-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-match (implies (cst-matchp abnf::cst "unann-type-variable") (b* ((abnf::cstss (cst-unann-type-variable-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-of-tree-fix-cst (equal (cst-unann-type-variable-conc (abnf::tree-fix abnf::cst)) (cst-unann-type-variable-conc abnf::cst)))
Theorem:
(defthm cst-unann-type-variable-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-variable-conc abnf::cst) (cst-unann-type-variable-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-method-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "method-declaration"))) (let ((__function__ 'cst-method-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-method-declaration-conc (b* ((abnf::cstss (cst-method-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-method-declaration-conc-match (implies (cst-matchp abnf::cst "method-declaration") (b* ((abnf::cstss (cst-method-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*method-modifier method-header method-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-method-declaration-conc-of-tree-fix-cst (equal (cst-method-declaration-conc (abnf::tree-fix abnf::cst)) (cst-method-declaration-conc abnf::cst)))
Theorem:
(defthm cst-method-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-method-declaration-conc abnf::cst) (cst-method-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-method-declarator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "method-declarator"))) (let ((__function__ 'cst-method-declarator-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-method-declarator-conc (b* ((abnf::cstss (cst-method-declarator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-method-declarator-conc-match (implies (cst-matchp abnf::cst "method-declarator") (b* ((abnf::cstss (cst-method-declarator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-method-declarator-conc-of-tree-fix-cst (equal (cst-method-declarator-conc (abnf::tree-fix abnf::cst)) (cst-method-declarator-conc abnf::cst)))
Theorem:
(defthm cst-method-declarator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-method-declarator-conc abnf::cst) (cst-method-declarator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-receiver-parameter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "receiver-parameter"))) (let ((__function__ 'cst-receiver-parameter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-receiver-parameter-conc (b* ((abnf::cstss (cst-receiver-parameter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-receiver-parameter-conc-match (implies (cst-matchp abnf::cst "receiver-parameter") (b* ((abnf::cstss (cst-receiver-parameter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation unann-type [ identifier \".\" ] %s\"this\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-receiver-parameter-conc-of-tree-fix-cst (equal (cst-receiver-parameter-conc (abnf::tree-fix abnf::cst)) (cst-receiver-parameter-conc abnf::cst)))
Theorem:
(defthm cst-receiver-parameter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-receiver-parameter-conc abnf::cst) (cst-receiver-parameter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-formal-parameter-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "formal-parameter-list"))) (let ((__function__ 'cst-formal-parameter-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-formal-parameter-list-conc (b* ((abnf::cstss (cst-formal-parameter-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-formal-parameter-list-conc-match (implies (cst-matchp abnf::cst "formal-parameter-list") (b* ((abnf::cstss (cst-formal-parameter-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "formal-parameter *( \",\" formal-parameter )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-formal-parameter-list-conc-of-tree-fix-cst (equal (cst-formal-parameter-list-conc (abnf::tree-fix abnf::cst)) (cst-formal-parameter-list-conc abnf::cst)))
Theorem:
(defthm cst-formal-parameter-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-formal-parameter-list-conc abnf::cst) (cst-formal-parameter-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-arity-parameter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-arity-parameter"))) (let ((__function__ 'cst-variable-arity-parameter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-arity-parameter-conc (b* ((abnf::cstss (cst-variable-arity-parameter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-arity-parameter-conc-match (implies (cst-matchp abnf::cst "variable-arity-parameter") (b* ((abnf::cstss (cst-variable-arity-parameter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*variable-modifier unann-type *annotation \"...\" identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-arity-parameter-conc-of-tree-fix-cst (equal (cst-variable-arity-parameter-conc (abnf::tree-fix abnf::cst)) (cst-variable-arity-parameter-conc abnf::cst)))
Theorem:
(defthm cst-variable-arity-parameter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-arity-parameter-conc abnf::cst) (cst-variable-arity-parameter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-throws-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "throws"))) (let ((__function__ 'cst-throws-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-throws-conc (b* ((abnf::cstss (cst-throws-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-throws-conc-match (implies (cst-matchp abnf::cst "throws") (b* ((abnf::cstss (cst-throws-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"throws\" exception-type-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-throws-conc-of-tree-fix-cst (equal (cst-throws-conc (abnf::tree-fix abnf::cst)) (cst-throws-conc abnf::cst)))
Theorem:
(defthm cst-throws-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-throws-conc abnf::cst) (cst-throws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exception-type-list"))) (let ((__function__ 'cst-exception-type-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exception-type-list-conc (b* ((abnf::cstss (cst-exception-type-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-list-conc-match (implies (cst-matchp abnf::cst "exception-type-list") (b* ((abnf::cstss (cst-exception-type-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "exception-type *( \",\" exception-type )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-list-conc-of-tree-fix-cst (equal (cst-exception-type-list-conc (abnf::tree-fix abnf::cst)) (cst-exception-type-list-conc abnf::cst)))
Theorem:
(defthm cst-exception-type-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-list-conc abnf::cst) (cst-exception-type-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-exception-type-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exception-type-conc1 (b* ((abnf::cstss (cst-exception-type-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-exception-type-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-of-tree-fix-cst (equal (cst-exception-type-conc1 (abnf::tree-fix abnf::cst)) (cst-exception-type-conc1 abnf::cst)))
Theorem:
(defthm cst-exception-type-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc1 abnf::cst) (cst-exception-type-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-exception-type-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exception-type-conc2 (b* ((abnf::cstss (cst-exception-type-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-exception-type-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-of-tree-fix-cst (equal (cst-exception-type-conc2 (abnf::tree-fix abnf::cst)) (cst-exception-type-conc2 abnf::cst)))
Theorem:
(defthm cst-exception-type-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc2 abnf::cst) (cst-exception-type-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-instance-initializer-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "instance-initializer"))) (let ((__function__ 'cst-instance-initializer-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-instance-initializer-conc (b* ((abnf::cstss (cst-instance-initializer-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-match (implies (cst-matchp abnf::cst "instance-initializer") (b* ((abnf::cstss (cst-instance-initializer-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-of-tree-fix-cst (equal (cst-instance-initializer-conc (abnf::tree-fix abnf::cst)) (cst-instance-initializer-conc abnf::cst)))
Theorem:
(defthm cst-instance-initializer-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-instance-initializer-conc abnf::cst) (cst-instance-initializer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-static-initializer-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "static-initializer"))) (let ((__function__ 'cst-static-initializer-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-static-initializer-conc (b* ((abnf::cstss (cst-static-initializer-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-static-initializer-conc-match (implies (cst-matchp abnf::cst "static-initializer") (b* ((abnf::cstss (cst-static-initializer-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"static\" block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-static-initializer-conc-of-tree-fix-cst (equal (cst-static-initializer-conc (abnf::tree-fix abnf::cst)) (cst-static-initializer-conc abnf::cst)))
Theorem:
(defthm cst-static-initializer-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-static-initializer-conc abnf::cst) (cst-static-initializer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constructor-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constructor-declaration"))) (let ((__function__ 'cst-constructor-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constructor-declaration-conc (b* ((abnf::cstss (cst-constructor-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-declaration-conc-match (implies (cst-matchp abnf::cst "constructor-declaration") (b* ((abnf::cstss (cst-constructor-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*constructor-modifier constructor-declarator [ throws ] constructor-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-declaration-conc-of-tree-fix-cst (equal (cst-constructor-declaration-conc (abnf::tree-fix abnf::cst)) (cst-constructor-declaration-conc abnf::cst)))
Theorem:
(defthm cst-constructor-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constructor-declaration-conc abnf::cst) (cst-constructor-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constructor-declarator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constructor-declarator"))) (let ((__function__ 'cst-constructor-declarator-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constructor-declarator-conc (b* ((abnf::cstss (cst-constructor-declarator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-declarator-conc-match (implies (cst-matchp abnf::cst "constructor-declarator") (b* ((abnf::cstss (cst-constructor-declarator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-declarator-conc-of-tree-fix-cst (equal (cst-constructor-declarator-conc (abnf::tree-fix abnf::cst)) (cst-constructor-declarator-conc abnf::cst)))
Theorem:
(defthm cst-constructor-declarator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constructor-declarator-conc abnf::cst) (cst-constructor-declarator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-simple-type-name-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name"))) (let ((__function__ 'cst-simple-type-name-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-simple-type-name-conc (b* ((abnf::cstss (cst-simple-type-name-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-match (implies (cst-matchp abnf::cst "simple-type-name") (b* ((abnf::cstss (cst-simple-type-name-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-of-tree-fix-cst (equal (cst-simple-type-name-conc (abnf::tree-fix abnf::cst)) (cst-simple-type-name-conc abnf::cst)))
Theorem:
(defthm cst-simple-type-name-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-simple-type-name-conc abnf::cst) (cst-simple-type-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constructor-body-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constructor-body"))) (let ((__function__ 'cst-constructor-body-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constructor-body-conc (b* ((abnf::cstss (cst-constructor-body-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-body-conc-match (implies (cst-matchp abnf::cst "constructor-body") (b* ((abnf::cstss (cst-constructor-body-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ explicit-constructor-invocation ] [ block-statements ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-constructor-body-conc-of-tree-fix-cst (equal (cst-constructor-body-conc (abnf::tree-fix abnf::cst)) (cst-constructor-body-conc abnf::cst)))
Theorem:
(defthm cst-constructor-body-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constructor-body-conc abnf::cst) (cst-constructor-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-declaration"))) (let ((__function__ 'cst-enum-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-declaration-conc (b* ((abnf::cstss (cst-enum-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-declaration-conc-match (implies (cst-matchp abnf::cst "enum-declaration") (b* ((abnf::cstss (cst-enum-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*class-modifier %s\"enum\" type-identifier [ superinterfaces ] enum-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-declaration-conc-of-tree-fix-cst (equal (cst-enum-declaration-conc (abnf::tree-fix abnf::cst)) (cst-enum-declaration-conc abnf::cst)))
Theorem:
(defthm cst-enum-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-declaration-conc abnf::cst) (cst-enum-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-body-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-body"))) (let ((__function__ 'cst-enum-body-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-body-conc (b* ((abnf::cstss (cst-enum-body-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-body-conc-match (implies (cst-matchp abnf::cst "enum-body") (b* ((abnf::cstss (cst-enum-body-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-body-conc-of-tree-fix-cst (equal (cst-enum-body-conc (abnf::tree-fix abnf::cst)) (cst-enum-body-conc abnf::cst)))
Theorem:
(defthm cst-enum-body-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-body-conc abnf::cst) (cst-enum-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-constant-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-constant-list"))) (let ((__function__ 'cst-enum-constant-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-constant-list-conc (b* ((abnf::cstss (cst-enum-constant-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-list-conc-match (implies (cst-matchp abnf::cst "enum-constant-list") (b* ((abnf::cstss (cst-enum-constant-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enum-constant *( \",\" enum-constant )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-list-conc-of-tree-fix-cst (equal (cst-enum-constant-list-conc (abnf::tree-fix abnf::cst)) (cst-enum-constant-list-conc abnf::cst)))
Theorem:
(defthm cst-enum-constant-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-constant-list-conc abnf::cst) (cst-enum-constant-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-constant-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-constant"))) (let ((__function__ 'cst-enum-constant-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-constant-conc (b* ((abnf::cstss (cst-enum-constant-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-conc-match (implies (cst-matchp abnf::cst "enum-constant") (b* ((abnf::cstss (cst-enum-constant-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-conc-of-tree-fix-cst (equal (cst-enum-constant-conc (abnf::tree-fix abnf::cst)) (cst-enum-constant-conc abnf::cst)))
Theorem:
(defthm cst-enum-constant-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-constant-conc abnf::cst) (cst-enum-constant-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-constant-modifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier"))) (let ((__function__ 'cst-enum-constant-modifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-constant-modifier-conc (b* ((abnf::cstss (cst-enum-constant-modifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-match (implies (cst-matchp abnf::cst "enum-constant-modifier") (b* ((abnf::cstss (cst-enum-constant-modifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-of-tree-fix-cst (equal (cst-enum-constant-modifier-conc (abnf::tree-fix abnf::cst)) (cst-enum-constant-modifier-conc abnf::cst)))
Theorem:
(defthm cst-enum-constant-modifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-constant-modifier-conc abnf::cst) (cst-enum-constant-modifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-body-declarations-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-body-declarations"))) (let ((__function__ 'cst-enum-body-declarations-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enum-body-declarations-conc (b* ((abnf::cstss (cst-enum-body-declarations-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-body-declarations-conc-match (implies (cst-matchp abnf::cst "enum-body-declarations") (b* ((abnf::cstss (cst-enum-body-declarations-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\";\" *class-body-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-body-declarations-conc-of-tree-fix-cst (equal (cst-enum-body-declarations-conc (abnf::tree-fix abnf::cst)) (cst-enum-body-declarations-conc abnf::cst)))
Theorem:
(defthm cst-enum-body-declarations-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-body-declarations-conc abnf::cst) (cst-enum-body-declarations-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-interface-declaration-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-declaration-conc1 (b* ((abnf::cstss (cst-interface-declaration-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-interface-declaration-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "normal-interface-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-of-tree-fix-cst (equal (cst-interface-declaration-conc1 (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc1 abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc1 abnf::cst) (cst-interface-declaration-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-interface-declaration-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-declaration-conc2 (b* ((abnf::cstss (cst-interface-declaration-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-interface-declaration-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "annotation-type-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-of-tree-fix-cst (equal (cst-interface-declaration-conc2 (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc2 abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc2 abnf::cst) (cst-interface-declaration-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-normal-interface-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "normal-interface-declaration"))) (let ((__function__ 'cst-normal-interface-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-normal-interface-declaration-conc (b* ((abnf::cstss (cst-normal-interface-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-interface-declaration-conc-match (implies (cst-matchp abnf::cst "normal-interface-declaration") (b* ((abnf::cstss (cst-normal-interface-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ extends-interfaces ] interface-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-interface-declaration-conc-of-tree-fix-cst (equal (cst-normal-interface-declaration-conc (abnf::tree-fix abnf::cst)) (cst-normal-interface-declaration-conc abnf::cst)))
Theorem:
(defthm cst-normal-interface-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-normal-interface-declaration-conc abnf::cst) (cst-normal-interface-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-extends-interfaces-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "extends-interfaces"))) (let ((__function__ 'cst-extends-interfaces-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-extends-interfaces-conc (b* ((abnf::cstss (cst-extends-interfaces-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-extends-interfaces-conc-match (implies (cst-matchp abnf::cst "extends-interfaces") (b* ((abnf::cstss (cst-extends-interfaces-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"extends\" interface-type-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-extends-interfaces-conc-of-tree-fix-cst (equal (cst-extends-interfaces-conc (abnf::tree-fix abnf::cst)) (cst-extends-interfaces-conc abnf::cst)))
Theorem:
(defthm cst-extends-interfaces-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-extends-interfaces-conc abnf::cst) (cst-extends-interfaces-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-body-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-body"))) (let ((__function__ 'cst-interface-body-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-body-conc (b* ((abnf::cstss (cst-interface-body-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-body-conc-match (implies (cst-matchp abnf::cst "interface-body") (b* ((abnf::cstss (cst-interface-body-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" *interface-member-declaration \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-body-conc-of-tree-fix-cst (equal (cst-interface-body-conc (abnf::tree-fix abnf::cst)) (cst-interface-body-conc abnf::cst)))
Theorem:
(defthm cst-interface-body-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-body-conc abnf::cst) (cst-interface-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-declaration"))) (let ((__function__ 'cst-constant-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constant-declaration-conc (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-declaration-conc-match (implies (cst-matchp abnf::cst "constant-declaration") (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*constant-modifier unann-type variable-declarator-list \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-declaration-conc-of-tree-fix-cst (equal (cst-constant-declaration-conc (abnf::tree-fix abnf::cst)) (cst-constant-declaration-conc abnf::cst)))
Theorem:
(defthm cst-constant-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-declaration-conc abnf::cst) (cst-constant-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-method-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-method-declaration"))) (let ((__function__ 'cst-interface-method-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-interface-method-declaration-conc (b* ((abnf::cstss (cst-interface-method-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-method-declaration-conc-match (implies (cst-matchp abnf::cst "interface-method-declaration") (b* ((abnf::cstss (cst-interface-method-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*interface-method-modifier method-header method-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-method-declaration-conc-of-tree-fix-cst (equal (cst-interface-method-declaration-conc (abnf::tree-fix abnf::cst)) (cst-interface-method-declaration-conc abnf::cst)))
Theorem:
(defthm cst-interface-method-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-method-declaration-conc abnf::cst) (cst-interface-method-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-type-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "annotation-type-declaration"))) (let ((__function__ 'cst-annotation-type-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-type-declaration-conc (b* ((abnf::cstss (cst-annotation-type-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-declaration-conc-match (implies (cst-matchp abnf::cst "annotation-type-declaration") (b* ((abnf::cstss (cst-annotation-type-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-type-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-declaration-conc-of-tree-fix-cst (equal (cst-annotation-type-declaration-conc (abnf::tree-fix abnf::cst)) (cst-annotation-type-declaration-conc abnf::cst)))
Theorem:
(defthm cst-annotation-type-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-type-declaration-conc abnf::cst) (cst-annotation-type-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-type-body-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "annotation-type-body"))) (let ((__function__ 'cst-annotation-type-body-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-type-body-conc (b* ((abnf::cstss (cst-annotation-type-body-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-body-conc-match (implies (cst-matchp abnf::cst "annotation-type-body") (b* ((abnf::cstss (cst-annotation-type-body-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" *annotation-type-member-declaration \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-body-conc-of-tree-fix-cst (equal (cst-annotation-type-body-conc (abnf::tree-fix abnf::cst)) (cst-annotation-type-body-conc abnf::cst)))
Theorem:
(defthm cst-annotation-type-body-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-type-body-conc abnf::cst) (cst-annotation-type-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-type-element-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "annotation-type-element-declaration"))) (let ((__function__ 'cst-annotation-type-element-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-type-element-declaration-conc (b* ((abnf::cstss (cst-annotation-type-element-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-element-declaration-conc-match (implies (cst-matchp abnf::cst "annotation-type-element-declaration") (b* ((abnf::cstss (cst-annotation-type-element-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation-type-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-type-element-declaration-conc-of-tree-fix-cst (equal (cst-annotation-type-element-declaration-conc (abnf::tree-fix abnf::cst)) (cst-annotation-type-element-declaration-conc abnf::cst)))
Theorem:
(defthm cst-annotation-type-element-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-type-element-declaration-conc abnf::cst) (cst-annotation-type-element-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-default-value-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "default-value"))) (let ((__function__ 'cst-default-value-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-default-value-conc (b* ((abnf::cstss (cst-default-value-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-default-value-conc-match (implies (cst-matchp abnf::cst "default-value") (b* ((abnf::cstss (cst-default-value-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"default\" element-value"))) :rule-classes :rewrite)
Theorem:
(defthm cst-default-value-conc-of-tree-fix-cst (equal (cst-default-value-conc (abnf::tree-fix abnf::cst)) (cst-default-value-conc abnf::cst)))
Theorem:
(defthm cst-default-value-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-default-value-conc abnf::cst) (cst-default-value-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)))) (let ((__function__ 'cst-annotation-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-conc1 (b* ((abnf::cstss (cst-annotation-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-annotation-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "normal-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-of-tree-fix-cst (equal (cst-annotation-conc1 (abnf::tree-fix abnf::cst)) (cst-annotation-conc1 abnf::cst)))
Theorem:
(defthm cst-annotation-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc1 abnf::cst) (cst-annotation-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)))) (let ((__function__ 'cst-annotation-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-conc2 (b* ((abnf::cstss (cst-annotation-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-annotation-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "marker-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-of-tree-fix-cst (equal (cst-annotation-conc2 (abnf::tree-fix abnf::cst)) (cst-annotation-conc2 abnf::cst)))
Theorem:
(defthm cst-annotation-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc2 abnf::cst) (cst-annotation-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)))) (let ((__function__ 'cst-annotation-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-annotation-conc3 (b* ((abnf::cstss (cst-annotation-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-annotation-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "single-element-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-of-tree-fix-cst (equal (cst-annotation-conc3 (abnf::tree-fix abnf::cst)) (cst-annotation-conc3 abnf::cst)))
Theorem:
(defthm cst-annotation-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc3 abnf::cst) (cst-annotation-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-normal-annotation-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "normal-annotation"))) (let ((__function__ 'cst-normal-annotation-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-normal-annotation-conc (b* ((abnf::cstss (cst-normal-annotation-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-annotation-conc-match (implies (cst-matchp abnf::cst "normal-annotation") (b* ((abnf::cstss (cst-normal-annotation-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name \"(\" [ element-value-pair-list ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-normal-annotation-conc-of-tree-fix-cst (equal (cst-normal-annotation-conc (abnf::tree-fix abnf::cst)) (cst-normal-annotation-conc abnf::cst)))
Theorem:
(defthm cst-normal-annotation-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-normal-annotation-conc abnf::cst) (cst-normal-annotation-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-pair-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "element-value-pair-list"))) (let ((__function__ 'cst-element-value-pair-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-pair-list-conc (b* ((abnf::cstss (cst-element-value-pair-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-pair-list-conc-match (implies (cst-matchp abnf::cst "element-value-pair-list") (b* ((abnf::cstss (cst-element-value-pair-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "element-value-pair *( \",\" element-value-pair )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-pair-list-conc-of-tree-fix-cst (equal (cst-element-value-pair-list-conc (abnf::tree-fix abnf::cst)) (cst-element-value-pair-list-conc abnf::cst)))
Theorem:
(defthm cst-element-value-pair-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-pair-list-conc abnf::cst) (cst-element-value-pair-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-pair-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "element-value-pair"))) (let ((__function__ 'cst-element-value-pair-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-pair-conc (b* ((abnf::cstss (cst-element-value-pair-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-pair-conc-match (implies (cst-matchp abnf::cst "element-value-pair") (b* ((abnf::cstss (cst-element-value-pair-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier \"=\" element-value"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-pair-conc-of-tree-fix-cst (equal (cst-element-value-pair-conc (abnf::tree-fix abnf::cst)) (cst-element-value-pair-conc abnf::cst)))
Theorem:
(defthm cst-element-value-pair-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-pair-conc abnf::cst) (cst-element-value-pair-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)))) (let ((__function__ 'cst-element-value-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-conc1 (b* ((abnf::cstss (cst-element-value-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-element-value-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-of-tree-fix-cst (equal (cst-element-value-conc1 (abnf::tree-fix abnf::cst)) (cst-element-value-conc1 abnf::cst)))
Theorem:
(defthm cst-element-value-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc1 abnf::cst) (cst-element-value-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)))) (let ((__function__ 'cst-element-value-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-conc2 (b* ((abnf::cstss (cst-element-value-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-element-value-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "element-value-array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-of-tree-fix-cst (equal (cst-element-value-conc2 (abnf::tree-fix abnf::cst)) (cst-element-value-conc2 abnf::cst)))
Theorem:
(defthm cst-element-value-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc2 abnf::cst) (cst-element-value-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)))) (let ((__function__ 'cst-element-value-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-conc3 (b* ((abnf::cstss (cst-element-value-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-element-value-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-of-tree-fix-cst (equal (cst-element-value-conc3 (abnf::tree-fix abnf::cst)) (cst-element-value-conc3 abnf::cst)))
Theorem:
(defthm cst-element-value-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc3 abnf::cst) (cst-element-value-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-array-initializer-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "element-value-array-initializer"))) (let ((__function__ 'cst-element-value-array-initializer-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-array-initializer-conc (b* ((abnf::cstss (cst-element-value-array-initializer-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-array-initializer-conc-match (implies (cst-matchp abnf::cst "element-value-array-initializer") (b* ((abnf::cstss (cst-element-value-array-initializer-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ element-value-list ] [ \",\" ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-array-initializer-conc-of-tree-fix-cst (equal (cst-element-value-array-initializer-conc (abnf::tree-fix abnf::cst)) (cst-element-value-array-initializer-conc abnf::cst)))
Theorem:
(defthm cst-element-value-array-initializer-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-array-initializer-conc abnf::cst) (cst-element-value-array-initializer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "element-value-list"))) (let ((__function__ 'cst-element-value-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-element-value-list-conc (b* ((abnf::cstss (cst-element-value-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-list-conc-match (implies (cst-matchp abnf::cst "element-value-list") (b* ((abnf::cstss (cst-element-value-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "element-value *( \",\" element-value )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-list-conc-of-tree-fix-cst (equal (cst-element-value-list-conc (abnf::tree-fix abnf::cst)) (cst-element-value-list-conc abnf::cst)))
Theorem:
(defthm cst-element-value-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-list-conc abnf::cst) (cst-element-value-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-marker-annotation-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "marker-annotation"))) (let ((__function__ 'cst-marker-annotation-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-marker-annotation-conc (b* ((abnf::cstss (cst-marker-annotation-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-marker-annotation-conc-match (implies (cst-matchp abnf::cst "marker-annotation") (b* ((abnf::cstss (cst-marker-annotation-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-marker-annotation-conc-of-tree-fix-cst (equal (cst-marker-annotation-conc (abnf::tree-fix abnf::cst)) (cst-marker-annotation-conc abnf::cst)))
Theorem:
(defthm cst-marker-annotation-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-marker-annotation-conc abnf::cst) (cst-marker-annotation-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-element-annotation-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-element-annotation"))) (let ((__function__ 'cst-single-element-annotation-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-single-element-annotation-conc (b* ((abnf::cstss (cst-single-element-annotation-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-element-annotation-conc-match (implies (cst-matchp abnf::cst "single-element-annotation") (b* ((abnf::cstss (cst-single-element-annotation-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name \"(\" element-value \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-element-annotation-conc-of-tree-fix-cst (equal (cst-single-element-annotation-conc (abnf::tree-fix abnf::cst)) (cst-single-element-annotation-conc abnf::cst)))
Theorem:
(defthm cst-single-element-annotation-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-element-annotation-conc abnf::cst) (cst-single-element-annotation-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-array-initializer-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "array-initializer"))) (let ((__function__ 'cst-array-initializer-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-array-initializer-conc (b* ((abnf::cstss (cst-array-initializer-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-array-initializer-conc-match (implies (cst-matchp abnf::cst "array-initializer") (b* ((abnf::cstss (cst-array-initializer-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-array-initializer-conc-of-tree-fix-cst (equal (cst-array-initializer-conc (abnf::tree-fix abnf::cst)) (cst-array-initializer-conc abnf::cst)))
Theorem:
(defthm cst-array-initializer-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-array-initializer-conc abnf::cst) (cst-array-initializer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "variable-initializer-list"))) (let ((__function__ 'cst-variable-initializer-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-initializer-list-conc (b* ((abnf::cstss (cst-variable-initializer-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-list-conc-match (implies (cst-matchp abnf::cst "variable-initializer-list") (b* ((abnf::cstss (cst-variable-initializer-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "variable-initializer *( \",\" variable-initializer )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-list-conc-of-tree-fix-cst (equal (cst-variable-initializer-list-conc (abnf::tree-fix abnf::cst)) (cst-variable-initializer-list-conc abnf::cst)))
Theorem:
(defthm cst-variable-initializer-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-list-conc abnf::cst) (cst-variable-initializer-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "block"))) (let ((__function__ 'cst-block-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-block-conc (b* ((abnf::cstss (cst-block-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-conc-match (implies (cst-matchp abnf::cst "block") (b* ((abnf::cstss (cst-block-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ block-statements ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-conc-of-tree-fix-cst (equal (cst-block-conc (abnf::tree-fix abnf::cst)) (cst-block-conc abnf::cst)))
Theorem:
(defthm cst-block-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-conc abnf::cst) (cst-block-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statements-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "block-statements"))) (let ((__function__ 'cst-block-statements-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-block-statements-conc (b* ((abnf::cstss (cst-block-statements-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statements-conc-match (implies (cst-matchp abnf::cst "block-statements") (b* ((abnf::cstss (cst-block-statements-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*block-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statements-conc-of-tree-fix-cst (equal (cst-block-statements-conc (abnf::tree-fix abnf::cst)) (cst-block-statements-conc abnf::cst)))
Theorem:
(defthm cst-block-statements-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statements-conc abnf::cst) (cst-block-statements-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-block-statement-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-block-statement-conc1 (b* ((abnf::cstss (cst-block-statement-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-block-statement-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-of-tree-fix-cst (equal (cst-block-statement-conc1 (abnf::tree-fix abnf::cst)) (cst-block-statement-conc1 abnf::cst)))
Theorem:
(defthm cst-block-statement-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc1 abnf::cst) (cst-block-statement-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-block-statement-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-block-statement-conc2 (b* ((abnf::cstss (cst-block-statement-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-block-statement-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-of-tree-fix-cst (equal (cst-block-statement-conc2 (abnf::tree-fix abnf::cst)) (cst-block-statement-conc2 abnf::cst)))
Theorem:
(defthm cst-block-statement-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc2 abnf::cst) (cst-block-statement-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-block-statement-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-block-statement-conc3 (b* ((abnf::cstss (cst-block-statement-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-block-statement-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-of-tree-fix-cst (equal (cst-block-statement-conc3 (abnf::tree-fix abnf::cst)) (cst-block-statement-conc3 abnf::cst)))
Theorem:
(defthm cst-block-statement-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc3 abnf::cst) (cst-block-statement-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-local-variable-declaration-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "local-variable-declaration-statement"))) (let ((__function__ 'cst-local-variable-declaration-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-local-variable-declaration-statement-conc (b* ((abnf::cstss (cst-local-variable-declaration-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-local-variable-declaration-statement-conc-match (implies (cst-matchp abnf::cst "local-variable-declaration-statement") (b* ((abnf::cstss (cst-local-variable-declaration-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-local-variable-declaration-statement-conc-of-tree-fix-cst (equal (cst-local-variable-declaration-statement-conc (abnf::tree-fix abnf::cst)) (cst-local-variable-declaration-statement-conc abnf::cst)))
Theorem:
(defthm cst-local-variable-declaration-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-local-variable-declaration-statement-conc abnf::cst) (cst-local-variable-declaration-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-local-variable-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "local-variable-declaration"))) (let ((__function__ 'cst-local-variable-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-local-variable-declaration-conc (b* ((abnf::cstss (cst-local-variable-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-local-variable-declaration-conc-match (implies (cst-matchp abnf::cst "local-variable-declaration") (b* ((abnf::cstss (cst-local-variable-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*variable-modifier local-variable-type variable-declarator-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-local-variable-declaration-conc-of-tree-fix-cst (equal (cst-local-variable-declaration-conc (abnf::tree-fix abnf::cst)) (cst-local-variable-declaration-conc abnf::cst)))
Theorem:
(defthm cst-local-variable-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-local-variable-declaration-conc abnf::cst) (cst-local-variable-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc1 (b* ((abnf::cstss (cst-statement-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-statement-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-of-tree-fix-cst (equal (cst-statement-conc1 (abnf::tree-fix abnf::cst)) (cst-statement-conc1 abnf::cst)))
Theorem:
(defthm cst-statement-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc1 abnf::cst) (cst-statement-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc2 (b* ((abnf::cstss (cst-statement-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-statement-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "labeled-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-of-tree-fix-cst (equal (cst-statement-conc2 (abnf::tree-fix abnf::cst)) (cst-statement-conc2 abnf::cst)))
Theorem:
(defthm cst-statement-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc2 abnf::cst) (cst-statement-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc3 (b* ((abnf::cstss (cst-statement-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-statement-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "if-then-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-of-tree-fix-cst (equal (cst-statement-conc3 (abnf::tree-fix abnf::cst)) (cst-statement-conc3 abnf::cst)))
Theorem:
(defthm cst-statement-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc3 abnf::cst) (cst-statement-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc4 (b* ((abnf::cstss (cst-statement-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-statement-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-of-tree-fix-cst (equal (cst-statement-conc4 (abnf::tree-fix abnf::cst)) (cst-statement-conc4 abnf::cst)))
Theorem:
(defthm cst-statement-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc4 abnf::cst) (cst-statement-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc5 (b* ((abnf::cstss (cst-statement-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-statement-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "while-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-of-tree-fix-cst (equal (cst-statement-conc5 (abnf::tree-fix abnf::cst)) (cst-statement-conc5 abnf::cst)))
Theorem:
(defthm cst-statement-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc5 abnf::cst) (cst-statement-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc6 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-conc6)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc6 (b* ((abnf::cstss (cst-statement-conc6 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::cstss (cst-statement-conc6 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-of-tree-fix-cst (equal (cst-statement-conc6 (abnf::tree-fix abnf::cst)) (cst-statement-conc6 abnf::cst)))
Theorem:
(defthm cst-statement-conc6-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc6 abnf::cst) (cst-statement-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-no-short-if-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-no-short-if-conc1 (b* ((abnf::cstss (cst-statement-no-short-if-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-statement-no-short-if-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-of-tree-fix-cst (equal (cst-statement-no-short-if-conc1 (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc1 abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc1 abnf::cst) (cst-statement-no-short-if-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-no-short-if-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-no-short-if-conc2 (b* ((abnf::cstss (cst-statement-no-short-if-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-statement-no-short-if-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "labeled-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-of-tree-fix-cst (equal (cst-statement-no-short-if-conc2 (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc2 abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc2 abnf::cst) (cst-statement-no-short-if-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-no-short-if-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-no-short-if-conc3 (b* ((abnf::cstss (cst-statement-no-short-if-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-statement-no-short-if-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-of-tree-fix-cst (equal (cst-statement-no-short-if-conc3 (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc3 abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc3 abnf::cst) (cst-statement-no-short-if-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-no-short-if-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-no-short-if-conc4 (b* ((abnf::cstss (cst-statement-no-short-if-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-statement-no-short-if-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "while-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-of-tree-fix-cst (equal (cst-statement-no-short-if-conc4 (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc4 abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc4 abnf::cst) (cst-statement-no-short-if-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-no-short-if-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-no-short-if-conc5 (b* ((abnf::cstss (cst-statement-no-short-if-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-statement-no-short-if-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-of-tree-fix-cst (equal (cst-statement-no-short-if-conc5 (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc5 abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc5 abnf::cst) (cst-statement-no-short-if-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc1 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc1 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc1 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc1 abnf::cst) (cst-statement-without-trailing-substatement-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc2 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "empty-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc2 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc2 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc2 abnf::cst) (cst-statement-without-trailing-substatement-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc3 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc3 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc3 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc3 abnf::cst) (cst-statement-without-trailing-substatement-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc4 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "assert-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc4 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc4 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc4 abnf::cst) (cst-statement-without-trailing-substatement-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc5 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "switch-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc5 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc5 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc5 abnf::cst) (cst-statement-without-trailing-substatement-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc6 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc6)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc6 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc6 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc6 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "do-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc6 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc6 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc6 abnf::cst) (cst-statement-without-trailing-substatement-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc7 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc7)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc7 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc7 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc7 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "break-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc7 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc7 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc7 abnf::cst) (cst-statement-without-trailing-substatement-conc7 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc8 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc8)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc8 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc8 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc8 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "continue-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc8 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc8 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc8 abnf::cst) (cst-statement-without-trailing-substatement-conc8 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc9 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc9)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc9 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc9 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc9 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "return-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc9 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc9 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc9 abnf::cst) (cst-statement-without-trailing-substatement-conc9 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc10 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc10)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc10 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc10 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc10 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "synchronized-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc10 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc10 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc10 abnf::cst) (cst-statement-without-trailing-substatement-conc10 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc11 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc11)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc11 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc11 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc11 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "throw-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc11 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc11 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc11 abnf::cst) (cst-statement-without-trailing-substatement-conc11 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc12 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc12)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc12 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc12 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc12 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "try-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc12 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc12 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc12 abnf::cst) (cst-statement-without-trailing-substatement-conc12 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc13 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc13)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-without-trailing-substatement-conc13 (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc13 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)) (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc13 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "yield-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc13 (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc13 abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc13 abnf::cst) (cst-statement-without-trailing-substatement-conc13 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-empty-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "empty-statement"))) (let ((__function__ 'cst-empty-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-empty-statement-conc (b* ((abnf::cstss (cst-empty-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-empty-statement-conc-match (implies (cst-matchp abnf::cst "empty-statement") (b* ((abnf::cstss (cst-empty-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-empty-statement-conc-of-tree-fix-cst (equal (cst-empty-statement-conc (abnf::tree-fix abnf::cst)) (cst-empty-statement-conc abnf::cst)))
Theorem:
(defthm cst-empty-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-empty-statement-conc abnf::cst) (cst-empty-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-labeled-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "labeled-statement"))) (let ((__function__ 'cst-labeled-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-labeled-statement-conc (b* ((abnf::cstss (cst-labeled-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-labeled-statement-conc-match (implies (cst-matchp abnf::cst "labeled-statement") (b* ((abnf::cstss (cst-labeled-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier \":\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-labeled-statement-conc-of-tree-fix-cst (equal (cst-labeled-statement-conc (abnf::tree-fix abnf::cst)) (cst-labeled-statement-conc abnf::cst)))
Theorem:
(defthm cst-labeled-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-labeled-statement-conc abnf::cst) (cst-labeled-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-labeled-statement-no-short-if-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "labeled-statement-no-short-if"))) (let ((__function__ 'cst-labeled-statement-no-short-if-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-labeled-statement-no-short-if-conc (b* ((abnf::cstss (cst-labeled-statement-no-short-if-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-labeled-statement-no-short-if-conc-match (implies (cst-matchp abnf::cst "labeled-statement-no-short-if") (b* ((abnf::cstss (cst-labeled-statement-no-short-if-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier \":\" statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-labeled-statement-no-short-if-conc-of-tree-fix-cst (equal (cst-labeled-statement-no-short-if-conc (abnf::tree-fix abnf::cst)) (cst-labeled-statement-no-short-if-conc abnf::cst)))
Theorem:
(defthm cst-labeled-statement-no-short-if-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-labeled-statement-no-short-if-conc abnf::cst) (cst-labeled-statement-no-short-if-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "expression-statement"))) (let ((__function__ 'cst-expression-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-expression-statement-conc (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-statement-conc-match (implies (cst-matchp abnf::cst "expression-statement") (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-expression \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-statement-conc-of-tree-fix-cst (equal (cst-expression-statement-conc (abnf::tree-fix abnf::cst)) (cst-expression-statement-conc abnf::cst)))
Theorem:
(defthm cst-expression-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-statement-conc abnf::cst) (cst-expression-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-expression-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc1 (b* ((abnf::cstss (cst-statement-expression-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-statement-expression-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-of-tree-fix-cst (equal (cst-statement-expression-conc1 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc1 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc1 abnf::cst) (cst-statement-expression-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-expression-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc2 (b* ((abnf::cstss (cst-statement-expression-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-statement-expression-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-of-tree-fix-cst (equal (cst-statement-expression-conc2 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc2 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc2 abnf::cst) (cst-statement-expression-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-expression-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc3 (b* ((abnf::cstss (cst-statement-expression-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-statement-expression-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-of-tree-fix-cst (equal (cst-statement-expression-conc3 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc3 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc3 abnf::cst) (cst-statement-expression-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-expression-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc4 (b* ((abnf::cstss (cst-statement-expression-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-statement-expression-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-of-tree-fix-cst (equal (cst-statement-expression-conc4 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc4 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc4 abnf::cst) (cst-statement-expression-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-expression-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc5 (b* ((abnf::cstss (cst-statement-expression-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-statement-expression-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-of-tree-fix-cst (equal (cst-statement-expression-conc5 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc5 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc5 abnf::cst) (cst-statement-expression-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc6 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-expression-conc6)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc6 (b* ((abnf::cstss (cst-statement-expression-conc6 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)) (b* ((abnf::cstss (cst-statement-expression-conc6 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "method-invocation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-of-tree-fix-cst (equal (cst-statement-expression-conc6 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc6 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc6-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc6 abnf::cst) (cst-statement-expression-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc7 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-expression-conc7)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-conc7 (b* ((abnf::cstss (cst-statement-expression-conc7 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)) (b* ((abnf::cstss (cst-statement-expression-conc7 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "class-instance-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-of-tree-fix-cst (equal (cst-statement-expression-conc7 (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc7 abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc7-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc7 abnf::cst) (cst-statement-expression-conc7 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-if-then-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "if-then-statement"))) (let ((__function__ 'cst-if-then-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-if-then-statement-conc (b* ((abnf::cstss (cst-if-then-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-statement-conc-match (implies (cst-matchp abnf::cst "if-then-statement") (b* ((abnf::cstss (cst-if-then-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-statement-conc-of-tree-fix-cst (equal (cst-if-then-statement-conc (abnf::tree-fix abnf::cst)) (cst-if-then-statement-conc abnf::cst)))
Theorem:
(defthm cst-if-then-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-if-then-statement-conc abnf::cst) (cst-if-then-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-if-then-else-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "if-then-else-statement"))) (let ((__function__ 'cst-if-then-else-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-if-then-else-statement-conc (b* ((abnf::cstss (cst-if-then-else-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-else-statement-conc-match (implies (cst-matchp abnf::cst "if-then-else-statement") (b* ((abnf::cstss (cst-if-then-else-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-else-statement-conc-of-tree-fix-cst (equal (cst-if-then-else-statement-conc (abnf::tree-fix abnf::cst)) (cst-if-then-else-statement-conc abnf::cst)))
Theorem:
(defthm cst-if-then-else-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-if-then-else-statement-conc abnf::cst) (cst-if-then-else-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-if-then-else-statement-no-short-if-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "if-then-else-statement-no-short-if"))) (let ((__function__ 'cst-if-then-else-statement-no-short-if-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-if-then-else-statement-no-short-if-conc (b* ((abnf::cstss (cst-if-then-else-statement-no-short-if-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-else-statement-no-short-if-conc-match (implies (cst-matchp abnf::cst "if-then-else-statement-no-short-if") (b* ((abnf::cstss (cst-if-then-else-statement-no-short-if-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-if-then-else-statement-no-short-if-conc-of-tree-fix-cst (equal (cst-if-then-else-statement-no-short-if-conc (abnf::tree-fix abnf::cst)) (cst-if-then-else-statement-no-short-if-conc abnf::cst)))
Theorem:
(defthm cst-if-then-else-statement-no-short-if-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-if-then-else-statement-no-short-if-conc abnf::cst) (cst-if-then-else-statement-no-short-if-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-switch-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "switch-statement"))) (let ((__function__ 'cst-switch-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-switch-statement-conc (b* ((abnf::cstss (cst-switch-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-statement-conc-match (implies (cst-matchp abnf::cst "switch-statement") (b* ((abnf::cstss (cst-switch-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-statement-conc-of-tree-fix-cst (equal (cst-switch-statement-conc (abnf::tree-fix abnf::cst)) (cst-switch-statement-conc abnf::cst)))
Theorem:
(defthm cst-switch-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-switch-statement-conc abnf::cst) (cst-switch-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-switch-block-statement-group-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "switch-block-statement-group"))) (let ((__function__ 'cst-switch-block-statement-group-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-switch-block-statement-group-conc (b* ((abnf::cstss (cst-switch-block-statement-group-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-block-statement-group-conc-match (implies (cst-matchp abnf::cst "switch-block-statement-group") (b* ((abnf::cstss (cst-switch-block-statement-group-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "switch-label \":\" *( switch-label \":\" ) block-statements"))) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-block-statement-group-conc-of-tree-fix-cst (equal (cst-switch-block-statement-group-conc (abnf::tree-fix abnf::cst)) (cst-switch-block-statement-group-conc abnf::cst)))
Theorem:
(defthm cst-switch-block-statement-group-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-switch-block-statement-group-conc abnf::cst) (cst-switch-block-statement-group-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-case-constant-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "case-constant"))) (let ((__function__ 'cst-case-constant-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-case-constant-conc (b* ((abnf::cstss (cst-case-constant-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-match (implies (cst-matchp abnf::cst "case-constant") (b* ((abnf::cstss (cst-case-constant-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-of-tree-fix-cst (equal (cst-case-constant-conc (abnf::tree-fix abnf::cst)) (cst-case-constant-conc abnf::cst)))
Theorem:
(defthm cst-case-constant-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-case-constant-conc abnf::cst) (cst-case-constant-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-while-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "while-statement"))) (let ((__function__ 'cst-while-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-while-statement-conc (b* ((abnf::cstss (cst-while-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-while-statement-conc-match (implies (cst-matchp abnf::cst "while-statement") (b* ((abnf::cstss (cst-while-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-while-statement-conc-of-tree-fix-cst (equal (cst-while-statement-conc (abnf::tree-fix abnf::cst)) (cst-while-statement-conc abnf::cst)))
Theorem:
(defthm cst-while-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-while-statement-conc abnf::cst) (cst-while-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-while-statement-no-short-if-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "while-statement-no-short-if"))) (let ((__function__ 'cst-while-statement-no-short-if-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-while-statement-no-short-if-conc (b* ((abnf::cstss (cst-while-statement-no-short-if-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-while-statement-no-short-if-conc-match (implies (cst-matchp abnf::cst "while-statement-no-short-if") (b* ((abnf::cstss (cst-while-statement-no-short-if-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-while-statement-no-short-if-conc-of-tree-fix-cst (equal (cst-while-statement-no-short-if-conc (abnf::tree-fix abnf::cst)) (cst-while-statement-no-short-if-conc abnf::cst)))
Theorem:
(defthm cst-while-statement-no-short-if-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-while-statement-no-short-if-conc abnf::cst) (cst-while-statement-no-short-if-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-do-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "do-statement"))) (let ((__function__ 'cst-do-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-do-statement-conc (b* ((abnf::cstss (cst-do-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-do-statement-conc-match (implies (cst-matchp abnf::cst "do-statement") (b* ((abnf::cstss (cst-do-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-do-statement-conc-of-tree-fix-cst (equal (cst-do-statement-conc (abnf::tree-fix abnf::cst)) (cst-do-statement-conc abnf::cst)))
Theorem:
(defthm cst-do-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-do-statement-conc abnf::cst) (cst-do-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-statement-conc1 (b* ((abnf::cstss (cst-for-statement-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-for-statement-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-of-tree-fix-cst (equal (cst-for-statement-conc1 (abnf::tree-fix abnf::cst)) (cst-for-statement-conc1 abnf::cst)))
Theorem:
(defthm cst-for-statement-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc1 abnf::cst) (cst-for-statement-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-statement-conc2 (b* ((abnf::cstss (cst-for-statement-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-for-statement-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-of-tree-fix-cst (equal (cst-for-statement-conc2 (abnf::tree-fix abnf::cst)) (cst-for-statement-conc2 abnf::cst)))
Theorem:
(defthm cst-for-statement-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc2 abnf::cst) (cst-for-statement-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-no-short-if-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-statement-no-short-if-conc1 (b* ((abnf::cstss (cst-for-statement-no-short-if-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-for-statement-no-short-if-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc1 (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc1 abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc1 abnf::cst) (cst-for-statement-no-short-if-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-no-short-if-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-statement-no-short-if-conc2 (b* ((abnf::cstss (cst-for-statement-no-short-if-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-for-statement-no-short-if-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc2 (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc2 abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc2 abnf::cst) (cst-for-statement-no-short-if-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-for-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-for-statement"))) (let ((__function__ 'cst-basic-for-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-for-statement-conc (b* ((abnf::cstss (cst-basic-for-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-for-statement-conc-match (implies (cst-matchp abnf::cst "basic-for-statement") (b* ((abnf::cstss (cst-basic-for-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-for-statement-conc-of-tree-fix-cst (equal (cst-basic-for-statement-conc (abnf::tree-fix abnf::cst)) (cst-basic-for-statement-conc abnf::cst)))
Theorem:
(defthm cst-basic-for-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-for-statement-conc abnf::cst) (cst-basic-for-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-for-statement-no-short-if-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-for-statement-no-short-if"))) (let ((__function__ 'cst-basic-for-statement-no-short-if-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-for-statement-no-short-if-conc (b* ((abnf::cstss (cst-basic-for-statement-no-short-if-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-for-statement-no-short-if-conc-match (implies (cst-matchp abnf::cst "basic-for-statement-no-short-if") (b* ((abnf::cstss (cst-basic-for-statement-no-short-if-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-for-statement-no-short-if-conc-of-tree-fix-cst (equal (cst-basic-for-statement-no-short-if-conc (abnf::tree-fix abnf::cst)) (cst-basic-for-statement-no-short-if-conc abnf::cst)))
Theorem:
(defthm cst-basic-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-for-statement-no-short-if-conc abnf::cst) (cst-basic-for-statement-no-short-if-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-init-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-init-conc1 (b* ((abnf::cstss (cst-for-init-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-for-init-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-of-tree-fix-cst (equal (cst-for-init-conc1 (abnf::tree-fix abnf::cst)) (cst-for-init-conc1 abnf::cst)))
Theorem:
(defthm cst-for-init-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc1 abnf::cst) (cst-for-init-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-init-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-init-conc2 (b* ((abnf::cstss (cst-for-init-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-for-init-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "local-variable-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-of-tree-fix-cst (equal (cst-for-init-conc2 (abnf::tree-fix abnf::cst)) (cst-for-init-conc2 abnf::cst)))
Theorem:
(defthm cst-for-init-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc2 abnf::cst) (cst-for-init-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-update-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-update"))) (let ((__function__ 'cst-for-update-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-for-update-conc (b* ((abnf::cstss (cst-for-update-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-match (implies (cst-matchp abnf::cst "for-update") (b* ((abnf::cstss (cst-for-update-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-of-tree-fix-cst (equal (cst-for-update-conc (abnf::tree-fix abnf::cst)) (cst-for-update-conc abnf::cst)))
Theorem:
(defthm cst-for-update-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-update-conc abnf::cst) (cst-for-update-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement-expression-list"))) (let ((__function__ 'cst-statement-expression-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-expression-list-conc (b* ((abnf::cstss (cst-statement-expression-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-list-conc-match (implies (cst-matchp abnf::cst "statement-expression-list") (b* ((abnf::cstss (cst-statement-expression-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement-expression *( \",\" statement-expression )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-list-conc-of-tree-fix-cst (equal (cst-statement-expression-list-conc (abnf::tree-fix abnf::cst)) (cst-statement-expression-list-conc abnf::cst)))
Theorem:
(defthm cst-statement-expression-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-list-conc abnf::cst) (cst-statement-expression-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enhanced-for-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enhanced-for-statement"))) (let ((__function__ 'cst-enhanced-for-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enhanced-for-statement-conc (b* ((abnf::cstss (cst-enhanced-for-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enhanced-for-statement-conc-match (implies (cst-matchp abnf::cst "enhanced-for-statement") (b* ((abnf::cstss (cst-enhanced-for-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enhanced-for-statement-conc-of-tree-fix-cst (equal (cst-enhanced-for-statement-conc (abnf::tree-fix abnf::cst)) (cst-enhanced-for-statement-conc abnf::cst)))
Theorem:
(defthm cst-enhanced-for-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enhanced-for-statement-conc abnf::cst) (cst-enhanced-for-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enhanced-for-statement-no-short-if-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enhanced-for-statement-no-short-if"))) (let ((__function__ 'cst-enhanced-for-statement-no-short-if-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-enhanced-for-statement-no-short-if-conc (b* ((abnf::cstss (cst-enhanced-for-statement-no-short-if-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-conc-match (implies (cst-matchp abnf::cst "enhanced-for-statement-no-short-if") (b* ((abnf::cstss (cst-enhanced-for-statement-no-short-if-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" *variable-modifier local-variable-type variable-declarator-id \":\" expression \")\" statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-conc-of-tree-fix-cst (equal (cst-enhanced-for-statement-no-short-if-conc (abnf::tree-fix abnf::cst)) (cst-enhanced-for-statement-no-short-if-conc abnf::cst)))
Theorem:
(defthm cst-enhanced-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enhanced-for-statement-no-short-if-conc abnf::cst) (cst-enhanced-for-statement-no-short-if-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-break-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "break-statement"))) (let ((__function__ 'cst-break-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-break-statement-conc (b* ((abnf::cstss (cst-break-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-break-statement-conc-match (implies (cst-matchp abnf::cst "break-statement") (b* ((abnf::cstss (cst-break-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"break\" [ identifier ] \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-break-statement-conc-of-tree-fix-cst (equal (cst-break-statement-conc (abnf::tree-fix abnf::cst)) (cst-break-statement-conc abnf::cst)))
Theorem:
(defthm cst-break-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-break-statement-conc abnf::cst) (cst-break-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-continue-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "continue-statement"))) (let ((__function__ 'cst-continue-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-continue-statement-conc (b* ((abnf::cstss (cst-continue-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-continue-statement-conc-match (implies (cst-matchp abnf::cst "continue-statement") (b* ((abnf::cstss (cst-continue-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"continue\" [ identifier ] \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-continue-statement-conc-of-tree-fix-cst (equal (cst-continue-statement-conc (abnf::tree-fix abnf::cst)) (cst-continue-statement-conc abnf::cst)))
Theorem:
(defthm cst-continue-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-continue-statement-conc abnf::cst) (cst-continue-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-return-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "return-statement"))) (let ((__function__ 'cst-return-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-return-statement-conc (b* ((abnf::cstss (cst-return-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-return-statement-conc-match (implies (cst-matchp abnf::cst "return-statement") (b* ((abnf::cstss (cst-return-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"return\" [ expression ] \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-return-statement-conc-of-tree-fix-cst (equal (cst-return-statement-conc (abnf::tree-fix abnf::cst)) (cst-return-statement-conc abnf::cst)))
Theorem:
(defthm cst-return-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-return-statement-conc abnf::cst) (cst-return-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-throw-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "throw-statement"))) (let ((__function__ 'cst-throw-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-throw-statement-conc (b* ((abnf::cstss (cst-throw-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-throw-statement-conc-match (implies (cst-matchp abnf::cst "throw-statement") (b* ((abnf::cstss (cst-throw-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"throw\" expression \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-throw-statement-conc-of-tree-fix-cst (equal (cst-throw-statement-conc (abnf::tree-fix abnf::cst)) (cst-throw-statement-conc abnf::cst)))
Theorem:
(defthm cst-throw-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-throw-statement-conc abnf::cst) (cst-throw-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-synchronized-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "synchronized-statement"))) (let ((__function__ 'cst-synchronized-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-synchronized-statement-conc (b* ((abnf::cstss (cst-synchronized-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-synchronized-statement-conc-match (implies (cst-matchp abnf::cst "synchronized-statement") (b* ((abnf::cstss (cst-synchronized-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\" \"(\" expression \")\" block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-synchronized-statement-conc-of-tree-fix-cst (equal (cst-synchronized-statement-conc (abnf::tree-fix abnf::cst)) (cst-synchronized-statement-conc abnf::cst)))
Theorem:
(defthm cst-synchronized-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-synchronized-statement-conc abnf::cst) (cst-synchronized-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-catches-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "catches"))) (let ((__function__ 'cst-catches-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-catches-conc (b* ((abnf::cstss (cst-catches-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-catches-conc-match (implies (cst-matchp abnf::cst "catches") (b* ((abnf::cstss (cst-catches-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*catch-clause"))) :rule-classes :rewrite)
Theorem:
(defthm cst-catches-conc-of-tree-fix-cst (equal (cst-catches-conc (abnf::tree-fix abnf::cst)) (cst-catches-conc abnf::cst)))
Theorem:
(defthm cst-catches-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-catches-conc abnf::cst) (cst-catches-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-catch-clause-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "catch-clause"))) (let ((__function__ 'cst-catch-clause-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-catch-clause-conc (b* ((abnf::cstss (cst-catch-clause-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-clause-conc-match (implies (cst-matchp abnf::cst "catch-clause") (b* ((abnf::cstss (cst-catch-clause-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"catch\" \"(\" catch-formal-parameter \")\" block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-clause-conc-of-tree-fix-cst (equal (cst-catch-clause-conc (abnf::tree-fix abnf::cst)) (cst-catch-clause-conc abnf::cst)))
Theorem:
(defthm cst-catch-clause-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-catch-clause-conc abnf::cst) (cst-catch-clause-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-catch-formal-parameter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "catch-formal-parameter"))) (let ((__function__ 'cst-catch-formal-parameter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-catch-formal-parameter-conc (b* ((abnf::cstss (cst-catch-formal-parameter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-formal-parameter-conc-match (implies (cst-matchp abnf::cst "catch-formal-parameter") (b* ((abnf::cstss (cst-catch-formal-parameter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*variable-modifier catch-type variable-declarator-id"))) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-formal-parameter-conc-of-tree-fix-cst (equal (cst-catch-formal-parameter-conc (abnf::tree-fix abnf::cst)) (cst-catch-formal-parameter-conc abnf::cst)))
Theorem:
(defthm cst-catch-formal-parameter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-catch-formal-parameter-conc abnf::cst) (cst-catch-formal-parameter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-catch-type-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "catch-type"))) (let ((__function__ 'cst-catch-type-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-catch-type-conc (b* ((abnf::cstss (cst-catch-type-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-type-conc-match (implies (cst-matchp abnf::cst "catch-type") (b* ((abnf::cstss (cst-catch-type-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "unann-class-type *( \"|\" class-type )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-catch-type-conc-of-tree-fix-cst (equal (cst-catch-type-conc (abnf::tree-fix abnf::cst)) (cst-catch-type-conc abnf::cst)))
Theorem:
(defthm cst-catch-type-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-catch-type-conc abnf::cst) (cst-catch-type-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-finally-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "finally"))) (let ((__function__ 'cst-finally-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-finally-conc (b* ((abnf::cstss (cst-finally-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-finally-conc-match (implies (cst-matchp abnf::cst "finally") (b* ((abnf::cstss (cst-finally-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"finally\" block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-finally-conc-of-tree-fix-cst (equal (cst-finally-conc (abnf::tree-fix abnf::cst)) (cst-finally-conc abnf::cst)))
Theorem:
(defthm cst-finally-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-finally-conc abnf::cst) (cst-finally-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-try-with-resources-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "try-with-resources-statement"))) (let ((__function__ 'cst-try-with-resources-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-try-with-resources-statement-conc (b* ((abnf::cstss (cst-try-with-resources-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-try-with-resources-statement-conc-match (implies (cst-matchp abnf::cst "try-with-resources-statement") (b* ((abnf::cstss (cst-try-with-resources-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"try\" resource-specification block [ catches ] [ finally ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-try-with-resources-statement-conc-of-tree-fix-cst (equal (cst-try-with-resources-statement-conc (abnf::tree-fix abnf::cst)) (cst-try-with-resources-statement-conc abnf::cst)))
Theorem:
(defthm cst-try-with-resources-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-try-with-resources-statement-conc abnf::cst) (cst-try-with-resources-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-resource-specification-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "resource-specification"))) (let ((__function__ 'cst-resource-specification-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-resource-specification-conc (b* ((abnf::cstss (cst-resource-specification-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-resource-specification-conc-match (implies (cst-matchp abnf::cst "resource-specification") (b* ((abnf::cstss (cst-resource-specification-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"(\" resource-list [ \";\" ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-resource-specification-conc-of-tree-fix-cst (equal (cst-resource-specification-conc (abnf::tree-fix abnf::cst)) (cst-resource-specification-conc abnf::cst)))
Theorem:
(defthm cst-resource-specification-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-resource-specification-conc abnf::cst) (cst-resource-specification-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-resource-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "resource-list"))) (let ((__function__ 'cst-resource-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-resource-list-conc (b* ((abnf::cstss (cst-resource-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-resource-list-conc-match (implies (cst-matchp abnf::cst "resource-list") (b* ((abnf::cstss (cst-resource-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "resource *( \";\" resource )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-resource-list-conc-of-tree-fix-cst (equal (cst-resource-list-conc (abnf::tree-fix abnf::cst)) (cst-resource-list-conc abnf::cst)))
Theorem:
(defthm cst-resource-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-resource-list-conc abnf::cst) (cst-resource-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-access-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-access-conc1 (b* ((abnf::cstss (cst-variable-access-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-variable-access-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-of-tree-fix-cst (equal (cst-variable-access-conc1 (abnf::tree-fix abnf::cst)) (cst-variable-access-conc1 abnf::cst)))
Theorem:
(defthm cst-variable-access-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc1 abnf::cst) (cst-variable-access-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-access-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-variable-access-conc2 (b* ((abnf::cstss (cst-variable-access-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-variable-access-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-of-tree-fix-cst (equal (cst-variable-access-conc2 (abnf::tree-fix abnf::cst)) (cst-variable-access-conc2 abnf::cst)))
Theorem:
(defthm cst-variable-access-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc2 abnf::cst) (cst-variable-access-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-yield-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "yield-statement"))) (let ((__function__ 'cst-yield-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-yield-statement-conc (b* ((abnf::cstss (cst-yield-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-yield-statement-conc-match (implies (cst-matchp abnf::cst "yield-statement") (b* ((abnf::cstss (cst-yield-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"yield\" expression \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-yield-statement-conc-of-tree-fix-cst (equal (cst-yield-statement-conc (abnf::tree-fix abnf::cst)) (cst-yield-statement-conc abnf::cst)))
Theorem:
(defthm cst-yield-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-yield-statement-conc abnf::cst) (cst-yield-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-expression-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-expression-conc1 (b* ((abnf::cstss (cst-expression-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-expression-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "lambda-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-of-tree-fix-cst (equal (cst-expression-conc1 (abnf::tree-fix abnf::cst)) (cst-expression-conc1 abnf::cst)))
Theorem:
(defthm cst-expression-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc1 abnf::cst) (cst-expression-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-expression-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-expression-conc2 (b* ((abnf::cstss (cst-expression-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-expression-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "assignment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-of-tree-fix-cst (equal (cst-expression-conc2 (abnf::tree-fix abnf::cst)) (cst-expression-conc2 abnf::cst)))
Theorem:
(defthm cst-expression-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc2 abnf::cst) (cst-expression-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)))) (let ((__function__ 'cst-primary-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-primary-conc1 (b* ((abnf::cstss (cst-primary-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-primary-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-of-tree-fix-cst (equal (cst-primary-conc1 (abnf::tree-fix abnf::cst)) (cst-primary-conc1 abnf::cst)))
Theorem:
(defthm cst-primary-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc1 abnf::cst) (cst-primary-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)))) (let ((__function__ 'cst-primary-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-primary-conc2 (b* ((abnf::cstss (cst-primary-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-primary-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "array-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-of-tree-fix-cst (equal (cst-primary-conc2 (abnf::tree-fix abnf::cst)) (cst-primary-conc2 abnf::cst)))
Theorem:
(defthm cst-primary-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc2 abnf::cst) (cst-primary-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unqualified-class-instance-creation-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unqualified-class-instance-creation-expression"))) (let ((__function__ 'cst-unqualified-class-instance-creation-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-unqualified-class-instance-creation-expression-conc (b* ((abnf::cstss (cst-unqualified-class-instance-creation-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-conc-match (implies (cst-matchp abnf::cst "unqualified-class-instance-creation-expression") (b* ((abnf::cstss (cst-unqualified-class-instance-creation-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-conc-of-tree-fix-cst (equal (cst-unqualified-class-instance-creation-expression-conc (abnf::tree-fix abnf::cst)) (cst-unqualified-class-instance-creation-expression-conc abnf::cst)))
Theorem:
(defthm cst-unqualified-class-instance-creation-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unqualified-class-instance-creation-expression-conc abnf::cst) (cst-unqualified-class-instance-creation-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-to-instantiate-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "class-or-interface-type-to-instantiate"))) (let ((__function__ 'cst-class-or-interface-type-to-instantiate-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-class-or-interface-type-to-instantiate-conc (b* ((abnf::cstss (cst-class-or-interface-type-to-instantiate-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-conc-match (implies (cst-matchp abnf::cst "class-or-interface-type-to-instantiate") (b* ((abnf::cstss (cst-class-or-interface-type-to-instantiate-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-conc-of-tree-fix-cst (equal (cst-class-or-interface-type-to-instantiate-conc (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-to-instantiate-conc abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-to-instantiate-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-to-instantiate-conc abnf::cst) (cst-class-or-interface-type-to-instantiate-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-dim-exprs-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "dim-exprs"))) (let ((__function__ 'cst-dim-exprs-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-dim-exprs-conc (b* ((abnf::cstss (cst-dim-exprs-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-dim-exprs-conc-match (implies (cst-matchp abnf::cst "dim-exprs") (b* ((abnf::cstss (cst-dim-exprs-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "1*dim-expr"))) :rule-classes :rewrite)
Theorem:
(defthm cst-dim-exprs-conc-of-tree-fix-cst (equal (cst-dim-exprs-conc (abnf::tree-fix abnf::cst)) (cst-dim-exprs-conc abnf::cst)))
Theorem:
(defthm cst-dim-exprs-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-dim-exprs-conc abnf::cst) (cst-dim-exprs-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-dim-expr-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "dim-expr"))) (let ((__function__ 'cst-dim-expr-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-dim-expr-conc (b* ((abnf::cstss (cst-dim-expr-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-dim-expr-conc-match (implies (cst-matchp abnf::cst "dim-expr") (b* ((abnf::cstss (cst-dim-expr-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "*annotation \"[\" expression \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-dim-expr-conc-of-tree-fix-cst (equal (cst-dim-expr-conc (abnf::tree-fix abnf::cst)) (cst-dim-expr-conc abnf::cst)))
Theorem:
(defthm cst-dim-expr-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-dim-expr-conc abnf::cst) (cst-dim-expr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-argument-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "argument-list"))) (let ((__function__ 'cst-argument-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-argument-list-conc (b* ((abnf::cstss (cst-argument-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-argument-list-conc-match (implies (cst-matchp abnf::cst "argument-list") (b* ((abnf::cstss (cst-argument-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression *( \",\" expression )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-argument-list-conc-of-tree-fix-cst (equal (cst-argument-list-conc (abnf::tree-fix abnf::cst)) (cst-argument-list-conc abnf::cst)))
Theorem:
(defthm cst-argument-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-argument-list-conc abnf::cst) (cst-argument-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-postfix-expression-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-postfix-expression-conc1 (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "primary"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-of-tree-fix-cst (equal (cst-postfix-expression-conc1 (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc1 abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc1 abnf::cst) (cst-postfix-expression-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-postfix-expression-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-postfix-expression-conc2 (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-of-tree-fix-cst (equal (cst-postfix-expression-conc2 (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc2 abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc2 abnf::cst) (cst-postfix-expression-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-postfix-expression-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-postfix-expression-conc3 (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-of-tree-fix-cst (equal (cst-postfix-expression-conc3 (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc3 abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc3 abnf::cst) (cst-postfix-expression-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-postfix-expression-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-postfix-expression-conc4 (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-of-tree-fix-cst (equal (cst-postfix-expression-conc4 (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc4 abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc4 abnf::cst) (cst-postfix-expression-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-post-increment-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "post-increment-expression"))) (let ((__function__ 'cst-post-increment-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-post-increment-expression-conc (b* ((abnf::cstss (cst-post-increment-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-post-increment-expression-conc-match (implies (cst-matchp abnf::cst "post-increment-expression") (b* ((abnf::cstss (cst-post-increment-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"++\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-post-increment-expression-conc-of-tree-fix-cst (equal (cst-post-increment-expression-conc (abnf::tree-fix abnf::cst)) (cst-post-increment-expression-conc abnf::cst)))
Theorem:
(defthm cst-post-increment-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-post-increment-expression-conc abnf::cst) (cst-post-increment-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-post-decrement-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "post-decrement-expression"))) (let ((__function__ 'cst-post-decrement-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-post-decrement-expression-conc (b* ((abnf::cstss (cst-post-decrement-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-post-decrement-expression-conc-match (implies (cst-matchp abnf::cst "post-decrement-expression") (b* ((abnf::cstss (cst-post-decrement-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"--\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-post-decrement-expression-conc-of-tree-fix-cst (equal (cst-post-decrement-expression-conc (abnf::tree-fix abnf::cst)) (cst-post-decrement-expression-conc abnf::cst)))
Theorem:
(defthm cst-post-decrement-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-post-decrement-expression-conc abnf::cst) (cst-post-decrement-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-pre-increment-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "pre-increment-expression"))) (let ((__function__ 'cst-pre-increment-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-pre-increment-expression-conc (b* ((abnf::cstss (cst-pre-increment-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-pre-increment-expression-conc-match (implies (cst-matchp abnf::cst "pre-increment-expression") (b* ((abnf::cstss (cst-pre-increment-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"++\" unary-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-pre-increment-expression-conc-of-tree-fix-cst (equal (cst-pre-increment-expression-conc (abnf::tree-fix abnf::cst)) (cst-pre-increment-expression-conc abnf::cst)))
Theorem:
(defthm cst-pre-increment-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-pre-increment-expression-conc abnf::cst) (cst-pre-increment-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-pre-decrement-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "pre-decrement-expression"))) (let ((__function__ 'cst-pre-decrement-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-pre-decrement-expression-conc (b* ((abnf::cstss (cst-pre-decrement-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-pre-decrement-expression-conc-match (implies (cst-matchp abnf::cst "pre-decrement-expression") (b* ((abnf::cstss (cst-pre-decrement-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"--\" unary-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-pre-decrement-expression-conc-of-tree-fix-cst (equal (cst-pre-decrement-expression-conc (abnf::tree-fix abnf::cst)) (cst-pre-decrement-expression-conc abnf::cst)))
Theorem:
(defthm cst-pre-decrement-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-pre-decrement-expression-conc abnf::cst) (cst-pre-decrement-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-assignment-expression-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-assignment-expression-conc1 (b* ((abnf::cstss (cst-assignment-expression-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-assignment-expression-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-of-tree-fix-cst (equal (cst-assignment-expression-conc1 (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc1 abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc1 abnf::cst) (cst-assignment-expression-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-assignment-expression-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-assignment-expression-conc2 (b* ((abnf::cstss (cst-assignment-expression-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-assignment-expression-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-of-tree-fix-cst (equal (cst-assignment-expression-conc2 (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc2 abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc2 abnf::cst) (cst-assignment-expression-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "assignment"))) (let ((__function__ 'cst-assignment-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-assignment-conc (b* ((abnf::cstss (cst-assignment-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-conc-match (implies (cst-matchp abnf::cst "assignment") (b* ((abnf::cstss (cst-assignment-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "left-hand-side assignment-operator expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-conc-of-tree-fix-cst (equal (cst-assignment-conc (abnf::tree-fix abnf::cst)) (cst-assignment-conc abnf::cst)))
Theorem:
(defthm cst-assignment-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-conc abnf::cst) (cst-assignment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)))) (let ((__function__ 'cst-left-hand-side-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-left-hand-side-conc1 (b* ((abnf::cstss (cst-left-hand-side-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-left-hand-side-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-of-tree-fix-cst (equal (cst-left-hand-side-conc1 (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc1 abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc1 abnf::cst) (cst-left-hand-side-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)))) (let ((__function__ 'cst-left-hand-side-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-left-hand-side-conc2 (b* ((abnf::cstss (cst-left-hand-side-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-left-hand-side-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-of-tree-fix-cst (equal (cst-left-hand-side-conc2 (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc2 abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc2 abnf::cst) (cst-left-hand-side-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)))) (let ((__function__ 'cst-left-hand-side-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-left-hand-side-conc3 (b* ((abnf::cstss (cst-left-hand-side-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-left-hand-side-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "array-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-of-tree-fix-cst (equal (cst-left-hand-side-conc3 (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc3 abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc3 abnf::cst) (cst-left-hand-side-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lambda-expression"))) (let ((__function__ 'cst-lambda-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-lambda-expression-conc (b* ((abnf::cstss (cst-lambda-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-expression-conc-match (implies (cst-matchp abnf::cst "lambda-expression") (b* ((abnf::cstss (cst-lambda-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "lambda-parameters \"->\" lambda-body"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-expression-conc-of-tree-fix-cst (equal (cst-lambda-expression-conc (abnf::tree-fix abnf::cst)) (cst-lambda-expression-conc abnf::cst)))
Theorem:
(defthm cst-lambda-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-expression-conc abnf::cst) (cst-lambda-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)))) (let ((__function__ 'cst-lambda-body-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-lambda-body-conc1 (b* ((abnf::cstss (cst-lambda-body-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-lambda-body-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-of-tree-fix-cst (equal (cst-lambda-body-conc1 (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc1 abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc1 abnf::cst) (cst-lambda-body-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)))) (let ((__function__ 'cst-lambda-body-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-lambda-body-conc2 (b* ((abnf::cstss (cst-lambda-body-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-lambda-body-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-of-tree-fix-cst (equal (cst-lambda-body-conc2 (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc2 abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc2 abnf::cst) (cst-lambda-body-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-switch-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "switch-expression"))) (let ((__function__ 'cst-switch-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-switch-expression-conc (b* ((abnf::cstss (cst-switch-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-expression-conc-match (implies (cst-matchp abnf::cst "switch-expression") (b* ((abnf::cstss (cst-switch-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" switch-block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-switch-expression-conc-of-tree-fix-cst (equal (cst-switch-expression-conc (abnf::tree-fix abnf::cst)) (cst-switch-expression-conc abnf::cst)))
Theorem:
(defthm cst-switch-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-switch-expression-conc abnf::cst) (cst-switch-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constant-expression-conc (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-of-tree-fix-cst (equal (cst-constant-expression-conc (abnf::tree-fix abnf::cst)) (cst-constant-expression-conc abnf::cst)))
Theorem:
(defthm cst-constant-expression-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-expression-conc abnf::cst) (cst-constant-expression-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-input-character-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unicode-input-character-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unicode-input-character-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unicode-input-character-conc1-rep (b* ((abnf::csts (cst-unicode-input-character-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-rep-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-unicode-input-character-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unicode-escape"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-rep-of-tree-fix-cst (equal (cst-unicode-input-character-conc1-rep (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc1-rep abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc1-rep abnf::cst) (cst-unicode-input-character-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-input-character-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unicode-input-character-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unicode-input-character-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unicode-input-character-conc2-rep (b* ((abnf::csts (cst-unicode-input-character-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-rep-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-unicode-input-character-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-rep-of-tree-fix-cst (equal (cst-unicode-input-character-conc2-rep (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc2-rep abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc2-rep abnf::cst) (cst-unicode-input-character-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-raw-input-character-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "raw-input-character"))) (let ((__function__ 'cst-raw-input-character-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-raw-input-character-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-raw-input-character-conc-rep (b* ((abnf::csts (cst-raw-input-character-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-raw-input-character-conc-rep-match (implies (cst-matchp abnf::cst "raw-input-character") (b* ((abnf::csts (cst-raw-input-character-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x0-FFFF"))) :rule-classes :rewrite)
Theorem:
(defthm cst-raw-input-character-conc-rep-of-tree-fix-cst (equal (cst-raw-input-character-conc-rep (abnf::tree-fix abnf::cst)) (cst-raw-input-character-conc-rep abnf::cst)))
Theorem:
(defthm cst-raw-input-character-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-raw-input-character-conc-rep abnf::cst) (cst-raw-input-character-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-character-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "input-character"))) (let ((__function__ 'cst-input-character-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-input-character-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-input-character-conc-rep (b* ((abnf::csts (cst-input-character-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-rep-match (implies (cst-matchp abnf::cst "input-character") (b* ((abnf::csts (cst-input-character-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unicode-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-rep-of-tree-fix-cst (equal (cst-input-character-conc-rep (abnf::tree-fix abnf::cst)) (cst-input-character-conc-rep abnf::cst)))
Theorem:
(defthm cst-input-character-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-character-conc-rep abnf::cst) (cst-input-character-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)))) (let ((__function__ 'cst-input-element-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-input-element-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-input-element-conc1-rep (b* ((abnf::csts (cst-input-element-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-rep-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-input-element-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-rep-of-tree-fix-cst (equal (cst-input-element-conc1-rep (abnf::tree-fix abnf::cst)) (cst-input-element-conc1-rep abnf::cst)))
Theorem:
(defthm cst-input-element-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc1-rep abnf::cst) (cst-input-element-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)))) (let ((__function__ 'cst-input-element-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-input-element-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-input-element-conc2-rep (b* ((abnf::csts (cst-input-element-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-rep-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-input-element-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-rep-of-tree-fix-cst (equal (cst-input-element-conc2-rep (abnf::tree-fix abnf::cst)) (cst-input-element-conc2-rep abnf::cst)))
Theorem:
(defthm cst-input-element-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc2-rep abnf::cst) (cst-input-element-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)))) (let ((__function__ 'cst-input-element-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-input-element-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-input-element-conc3-rep (b* ((abnf::csts (cst-input-element-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-rep-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-input-element-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-rep-of-tree-fix-cst (equal (cst-input-element-conc3-rep (abnf::tree-fix abnf::cst)) (cst-input-element-conc3-rep abnf::cst)))
Theorem:
(defthm cst-input-element-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc3-rep abnf::cst) (cst-input-element-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc1-rep (b* ((abnf::csts (cst-token-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-token-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-of-tree-fix-cst (equal (cst-token-conc1-rep (abnf::tree-fix abnf::cst)) (cst-token-conc1-rep abnf::cst)))
Theorem:
(defthm cst-token-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc1-rep abnf::cst) (cst-token-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)))) (let ((__function__ 'cst-token-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc2-rep (b* ((abnf::csts (cst-token-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-token-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "keyword"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-of-tree-fix-cst (equal (cst-token-conc2-rep (abnf::tree-fix abnf::cst)) (cst-token-conc2-rep abnf::cst)))
Theorem:
(defthm cst-token-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc2-rep abnf::cst) (cst-token-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)))) (let ((__function__ 'cst-token-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc3-rep (b* ((abnf::csts (cst-token-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-token-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-of-tree-fix-cst (equal (cst-token-conc3-rep (abnf::tree-fix abnf::cst)) (cst-token-conc3-rep abnf::cst)))
Theorem:
(defthm cst-token-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc3-rep abnf::cst) (cst-token-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)))) (let ((__function__ 'cst-token-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc4-rep (b* ((abnf::csts (cst-token-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-token-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "separator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-of-tree-fix-cst (equal (cst-token-conc4-rep (abnf::tree-fix abnf::cst)) (cst-token-conc4-rep abnf::cst)))
Theorem:
(defthm cst-token-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4-rep abnf::cst) (cst-token-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc5-rep (b* ((abnf::csts (cst-token-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-token-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "operator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-of-tree-fix-cst (equal (cst-token-conc5-rep (abnf::tree-fix abnf::cst)) (cst-token-conc5-rep abnf::cst)))
Theorem:
(defthm cst-token-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5-rep abnf::cst) (cst-token-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-sub-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "sub"))) (let ((__function__ 'cst-sub-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-sub-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-sub-conc-rep (b* ((abnf::csts (cst-sub-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-sub-conc-rep-match (implies (cst-matchp abnf::cst "sub") (b* ((abnf::csts (cst-sub-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%d26"))) :rule-classes :rewrite)
Theorem:
(defthm cst-sub-conc-rep-of-tree-fix-cst (equal (cst-sub-conc-rep (abnf::tree-fix abnf::cst)) (cst-sub-conc-rep abnf::cst)))
Theorem:
(defthm cst-sub-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-sub-conc-rep abnf::cst) (cst-sub-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-comment-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-comment-conc1-rep (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "traditional-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-of-tree-fix-cst (equal (cst-comment-conc1-rep (abnf::tree-fix abnf::cst)) (cst-comment-conc1-rep abnf::cst)))
Theorem:
(defthm cst-comment-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc1-rep abnf::cst) (cst-comment-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)))) (let ((__function__ 'cst-comment-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-comment-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-comment-conc2-rep (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "end-of-line-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-of-tree-fix-cst (equal (cst-comment-conc2-rep (abnf::tree-fix abnf::cst)) (cst-comment-conc2-rep abnf::cst)))
Theorem:
(defthm cst-comment-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc2-rep abnf::cst) (cst-comment-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-not-star-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-not-star-conc1-rep (b* ((abnf::csts (cst-not-star-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-rep-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-not-star-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-rep-of-tree-fix-cst (equal (cst-not-star-conc1-rep (abnf::tree-fix abnf::cst)) (cst-not-star-conc1-rep abnf::cst)))
Theorem:
(defthm cst-not-star-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc1-rep abnf::cst) (cst-not-star-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-not-star-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-not-star-conc2-rep (b* ((abnf::csts (cst-not-star-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-rep-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-not-star-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-rep-of-tree-fix-cst (equal (cst-not-star-conc2-rep (abnf::tree-fix abnf::cst)) (cst-not-star-conc2-rep abnf::cst)))
Theorem:
(defthm cst-not-star-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc2-rep abnf::cst) (cst-not-star-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-not-slash-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-not-star-not-slash-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-not-star-not-slash-conc1-rep (b* ((abnf::csts (cst-not-star-not-slash-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-not-star-not-slash-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-of-tree-fix-cst (equal (cst-not-star-not-slash-conc1-rep (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc1-rep abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc1-rep abnf::cst) (cst-not-star-not-slash-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-not-slash-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-not-star-not-slash-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-not-star-not-slash-conc2-rep (b* ((abnf::csts (cst-not-star-not-slash-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-not-star-not-slash-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-of-tree-fix-cst (equal (cst-not-star-not-slash-conc2-rep (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc2-rep abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc2-rep abnf::cst) (cst-not-star-not-slash-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier"))) (let ((__function__ 'cst-identifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-identifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-identifier-conc-rep (b* ((abnf::csts (cst-identifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-rep-match (implies (cst-matchp abnf::cst "identifier") (b* ((abnf::csts (cst-identifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier-chars"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-rep-of-tree-fix-cst (equal (cst-identifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-identifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-identifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-conc-rep abnf::cst) (cst-identifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter"))) (let ((__function__ 'cst-java-letter-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-java-letter-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-java-letter-conc-rep (b* ((abnf::csts (cst-java-letter-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-rep-match (implies (cst-matchp abnf::cst "java-letter") (b* ((abnf::csts (cst-java-letter-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-rep-of-tree-fix-cst (equal (cst-java-letter-conc-rep (abnf::tree-fix abnf::cst)) (cst-java-letter-conc-rep abnf::cst)))
Theorem:
(defthm cst-java-letter-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-conc-rep abnf::cst) (cst-java-letter-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-or-digit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit"))) (let ((__function__ 'cst-java-letter-or-digit-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-java-letter-or-digit-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-java-letter-or-digit-conc-rep (b* ((abnf::csts (cst-java-letter-or-digit-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-match (implies (cst-matchp abnf::cst "java-letter-or-digit") (b* ((abnf::csts (cst-java-letter-or-digit-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-of-tree-fix-cst (equal (cst-java-letter-or-digit-conc-rep (abnf::tree-fix abnf::cst)) (cst-java-letter-or-digit-conc-rep abnf::cst)))
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-or-digit-conc-rep abnf::cst) (cst-java-letter-or-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-identifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-identifier"))) (let ((__function__ 'cst-type-identifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-identifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-identifier-conc-rep (b* ((abnf::csts (cst-type-identifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-rep-match (implies (cst-matchp abnf::cst "type-identifier") (b* ((abnf::csts (cst-type-identifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-rep-of-tree-fix-cst (equal (cst-type-identifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-type-identifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-type-identifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-identifier-conc-rep abnf::cst) (cst-type-identifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unqualified-method-identifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unqualified-method-identifier"))) (let ((__function__ 'cst-unqualified-method-identifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unqualified-method-identifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unqualified-method-identifier-conc-rep (b* ((abnf::csts (cst-unqualified-method-identifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-match (implies (cst-matchp abnf::cst "unqualified-method-identifier") (b* ((abnf::csts (cst-unqualified-method-identifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-of-tree-fix-cst (equal (cst-unqualified-method-identifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-unqualified-method-identifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unqualified-method-identifier-conc-rep abnf::cst) (cst-unqualified-method-identifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-literal-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc1-rep (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-rep-of-tree-fix-cst (equal (cst-literal-conc1-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc1-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc1-rep abnf::cst) (cst-literal-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-literal-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc2-rep (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-rep-of-tree-fix-cst (equal (cst-literal-conc2-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc2-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc2-rep abnf::cst) (cst-literal-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-literal-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc3-rep (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "boolean-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-rep-of-tree-fix-cst (equal (cst-literal-conc3-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc3-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc3-rep abnf::cst) (cst-literal-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-literal-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc4-rep (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "character-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-rep-of-tree-fix-cst (equal (cst-literal-conc4-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc4-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc4-rep abnf::cst) (cst-literal-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)))) (let ((__function__ 'cst-literal-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc5-rep (b* ((abnf::csts (cst-literal-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-literal-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-rep-of-tree-fix-cst (equal (cst-literal-conc5-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc5-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc5-rep abnf::cst) (cst-literal-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc6-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)))) (let ((__function__ 'cst-literal-conc6-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-literal-conc6 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-literal-conc6-rep (b* ((abnf::csts (cst-literal-conc6-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-rep-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)) (b* ((abnf::csts (cst-literal-conc6-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "null-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-rep-of-tree-fix-cst (equal (cst-literal-conc6-rep (abnf::tree-fix abnf::cst)) (cst-literal-conc6-rep abnf::cst)))
Theorem:
(defthm cst-literal-conc6-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc6-rep abnf::cst) (cst-literal-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-integer-literal-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-integer-literal-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-integer-literal-conc1-rep (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-rep-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "decimal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-rep-of-tree-fix-cst (equal (cst-integer-literal-conc1-rep (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc1-rep abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc1-rep abnf::cst) (cst-integer-literal-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-integer-literal-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-integer-literal-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-integer-literal-conc2-rep (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-rep-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "hex-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-rep-of-tree-fix-cst (equal (cst-integer-literal-conc2-rep (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc2-rep abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc2-rep abnf::cst) (cst-integer-literal-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-integer-literal-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-integer-literal-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-integer-literal-conc3-rep (b* ((abnf::csts (cst-integer-literal-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-rep-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-integer-literal-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "octal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-rep-of-tree-fix-cst (equal (cst-integer-literal-conc3-rep (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc3-rep abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc3-rep abnf::cst) (cst-integer-literal-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-integer-literal-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-integer-literal-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-integer-literal-conc4-rep (b* ((abnf::csts (cst-integer-literal-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-rep-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-integer-literal-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "binary-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-rep-of-tree-fix-cst (equal (cst-integer-literal-conc4-rep (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc4-rep abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc4-rep abnf::cst) (cst-integer-literal-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-type-suffix-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "integer-type-suffix"))) (let ((__function__ 'cst-integer-type-suffix-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-integer-type-suffix-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-integer-type-suffix-conc-rep (b* ((abnf::csts (cst-integer-type-suffix-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-type-suffix-conc-rep-match (implies (cst-matchp abnf::cst "integer-type-suffix") (b* ((abnf::csts (cst-integer-type-suffix-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "\"l\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-type-suffix-conc-rep-of-tree-fix-cst (equal (cst-integer-type-suffix-conc-rep (abnf::tree-fix abnf::cst)) (cst-integer-type-suffix-conc-rep abnf::cst)))
Theorem:
(defthm cst-integer-type-suffix-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-type-suffix-conc-rep abnf::cst) (cst-integer-type-suffix-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-point-literal-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-floating-point-literal-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-floating-point-literal-conc1-rep (b* ((abnf::csts (cst-floating-point-literal-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-rep-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-floating-point-literal-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "decimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-rep-of-tree-fix-cst (equal (cst-floating-point-literal-conc1-rep (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc1-rep abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc1-rep abnf::cst) (cst-floating-point-literal-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-point-literal-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-floating-point-literal-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-floating-point-literal-conc2-rep (b* ((abnf::csts (cst-floating-point-literal-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-rep-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-floating-point-literal-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "hexadecimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-rep-of-tree-fix-cst (equal (cst-floating-point-literal-conc2-rep (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc2-rep abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc2-rep abnf::cst) (cst-floating-point-literal-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exponent-indicator-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exponent-indicator"))) (let ((__function__ 'cst-exponent-indicator-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-exponent-indicator-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-exponent-indicator-conc-rep (b* ((abnf::csts (cst-exponent-indicator-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-indicator-conc-rep-match (implies (cst-matchp abnf::cst "exponent-indicator") (b* ((abnf::csts (cst-exponent-indicator-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "\"e\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-indicator-conc-rep-of-tree-fix-cst (equal (cst-exponent-indicator-conc-rep (abnf::tree-fix abnf::cst)) (cst-exponent-indicator-conc-rep abnf::cst)))
Theorem:
(defthm cst-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exponent-indicator-conc-rep abnf::cst) (cst-exponent-indicator-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-exponent-indicator-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-exponent-indicator"))) (let ((__function__ 'cst-binary-exponent-indicator-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-binary-exponent-indicator-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-binary-exponent-indicator-conc-rep (b* ((abnf::csts (cst-binary-exponent-indicator-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-indicator-conc-rep-match (implies (cst-matchp abnf::cst "binary-exponent-indicator") (b* ((abnf::csts (cst-binary-exponent-indicator-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "\"p\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-indicator-conc-rep-of-tree-fix-cst (equal (cst-binary-exponent-indicator-conc-rep (abnf::tree-fix abnf::cst)) (cst-binary-exponent-indicator-conc-rep abnf::cst)))
Theorem:
(defthm cst-binary-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-exponent-indicator-conc-rep abnf::cst) (cst-binary-exponent-indicator-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-character-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-character"))) (let ((__function__ 'cst-single-character-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-single-character-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-single-character-conc-rep (b* ((abnf::csts (cst-single-character-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-rep-match (implies (cst-matchp abnf::cst "single-character") (b* ((abnf::csts (cst-single-character-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-rep-of-tree-fix-cst (equal (cst-single-character-conc-rep (abnf::tree-fix abnf::cst)) (cst-single-character-conc-rep abnf::cst)))
Theorem:
(defthm cst-single-character-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-character-conc-rep abnf::cst) (cst-single-character-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-string-character-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-string-character-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-string-character-conc1-rep (b* ((abnf::csts (cst-string-character-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-rep-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-string-character-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-rep-of-tree-fix-cst (equal (cst-string-character-conc1-rep (abnf::tree-fix abnf::cst)) (cst-string-character-conc1-rep abnf::cst)))
Theorem:
(defthm cst-string-character-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc1-rep abnf::cst) (cst-string-character-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-string-character-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-string-character-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-string-character-conc2-rep (b* ((abnf::csts (cst-string-character-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-rep-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-string-character-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-rep-of-tree-fix-cst (equal (cst-string-character-conc2-rep (abnf::tree-fix abnf::cst)) (cst-string-character-conc2-rep abnf::cst)))
Theorem:
(defthm cst-string-character-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc2-rep abnf::cst) (cst-string-character-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-null-literal-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "null-literal"))) (let ((__function__ 'cst-null-literal-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-null-literal-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-null-literal-conc-rep (b* ((abnf::csts (cst-null-literal-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-null-literal-conc-rep-match (implies (cst-matchp abnf::cst "null-literal") (b* ((abnf::csts (cst-null-literal-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%s\"null\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-null-literal-conc-rep-of-tree-fix-cst (equal (cst-null-literal-conc-rep (abnf::tree-fix abnf::cst)) (cst-null-literal-conc-rep abnf::cst)))
Theorem:
(defthm cst-null-literal-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-null-literal-conc-rep abnf::cst) (cst-null-literal-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-conc1-rep (b* ((abnf::csts (cst-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-rep-of-tree-fix-cst (equal (cst-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc1-rep abnf::cst) (cst-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-conc2-rep (b* ((abnf::csts (cst-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-rep-of-tree-fix-cst (equal (cst-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc2-rep abnf::cst) (cst-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-numeric-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-numeric-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-numeric-type-conc1-rep (b* ((abnf::csts (cst-numeric-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-numeric-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "integral-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-rep-of-tree-fix-cst (equal (cst-numeric-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc1-rep abnf::cst) (cst-numeric-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-numeric-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-numeric-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-numeric-type-conc2-rep (b* ((abnf::csts (cst-numeric-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-numeric-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "floating-point-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-rep-of-tree-fix-cst (equal (cst-numeric-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc2-rep abnf::cst) (cst-numeric-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-reference-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-reference-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-reference-type-conc1-rep (b* ((abnf::csts (cst-reference-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-reference-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-rep-of-tree-fix-cst (equal (cst-reference-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-reference-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-reference-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc1-rep abnf::cst) (cst-reference-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-reference-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-reference-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-reference-type-conc2-rep (b* ((abnf::csts (cst-reference-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-reference-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-rep-of-tree-fix-cst (equal (cst-reference-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-reference-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-reference-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc2-rep abnf::cst) (cst-reference-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-reference-type-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-reference-type-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-reference-type-conc3-rep (b* ((abnf::csts (cst-reference-type-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-rep-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-reference-type-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-rep-of-tree-fix-cst (equal (cst-reference-type-conc3-rep (abnf::tree-fix abnf::cst)) (cst-reference-type-conc3-rep abnf::cst)))
Theorem:
(defthm cst-reference-type-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc3-rep abnf::cst) (cst-reference-type-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-or-interface-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-or-interface-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-or-interface-type-conc1-rep (b* ((abnf::csts (cst-class-or-interface-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-class-or-interface-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-of-tree-fix-cst (equal (cst-class-or-interface-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc1-rep abnf::cst) (cst-class-or-interface-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-or-interface-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-or-interface-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-or-interface-type-conc2-rep (b* ((abnf::csts (cst-class-or-interface-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-class-or-interface-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-of-tree-fix-cst (equal (cst-class-or-interface-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc2-rep abnf::cst) (cst-class-or-interface-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-type-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-type"))) (let ((__function__ 'cst-interface-type-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-interface-type-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-interface-type-conc-rep (b* ((abnf::csts (cst-interface-type-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-rep-match (implies (cst-matchp abnf::cst "interface-type") (b* ((abnf::csts (cst-interface-type-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-rep-of-tree-fix-cst (equal (cst-interface-type-conc-rep (abnf::tree-fix abnf::cst)) (cst-interface-type-conc-rep abnf::cst)))
Theorem:
(defthm cst-interface-type-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-type-conc-rep abnf::cst) (cst-interface-type-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameter-modifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier"))) (let ((__function__ 'cst-type-parameter-modifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-parameter-modifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-parameter-modifier-conc-rep (b* ((abnf::csts (cst-type-parameter-modifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-match (implies (cst-matchp abnf::cst "type-parameter-modifier") (b* ((abnf::csts (cst-type-parameter-modifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-of-tree-fix-cst (equal (cst-type-parameter-modifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-type-parameter-modifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameter-modifier-conc-rep abnf::cst) (cst-type-parameter-modifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-argument-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-argument-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-argument-conc1-rep (b* ((abnf::csts (cst-type-argument-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-rep-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-type-argument-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-rep-of-tree-fix-cst (equal (cst-type-argument-conc1-rep (abnf::tree-fix abnf::cst)) (cst-type-argument-conc1-rep abnf::cst)))
Theorem:
(defthm cst-type-argument-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc1-rep abnf::cst) (cst-type-argument-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-argument-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-type-argument-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-type-argument-conc2-rep (b* ((abnf::csts (cst-type-argument-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-rep-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-type-argument-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "wildcard"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-rep-of-tree-fix-cst (equal (cst-type-argument-conc2-rep (abnf::tree-fix abnf::cst)) (cst-type-argument-conc2-rep abnf::cst)))
Theorem:
(defthm cst-type-argument-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc2-rep abnf::cst) (cst-type-argument-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-method-name-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "method-name"))) (let ((__function__ 'cst-method-name-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-method-name-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-method-name-conc-rep (b* ((abnf::csts (cst-method-name-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-rep-match (implies (cst-matchp abnf::cst "method-name") (b* ((abnf::csts (cst-method-name-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unqualified-method-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-rep-of-tree-fix-cst (equal (cst-method-name-conc-rep (abnf::tree-fix abnf::cst)) (cst-method-name-conc-rep abnf::cst)))
Theorem:
(defthm cst-method-name-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-method-name-conc-rep abnf::cst) (cst-method-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)))) (let ((__function__ 'cst-compilation-unit-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-compilation-unit-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-compilation-unit-conc1-rep (b* ((abnf::csts (cst-compilation-unit-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-rep-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-compilation-unit-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "ordinary-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-rep-of-tree-fix-cst (equal (cst-compilation-unit-conc1-rep (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc1-rep abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc1-rep abnf::cst) (cst-compilation-unit-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)))) (let ((__function__ 'cst-compilation-unit-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-compilation-unit-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-compilation-unit-conc2-rep (b* ((abnf::csts (cst-compilation-unit-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-rep-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-compilation-unit-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "modular-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-rep-of-tree-fix-cst (equal (cst-compilation-unit-conc2-rep (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc2-rep abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc2-rep abnf::cst) (cst-compilation-unit-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-package-modifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "package-modifier"))) (let ((__function__ 'cst-package-modifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-package-modifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-package-modifier-conc-rep (b* ((abnf::csts (cst-package-modifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-rep-match (implies (cst-matchp abnf::cst "package-modifier") (b* ((abnf::csts (cst-package-modifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-rep-of-tree-fix-cst (equal (cst-package-modifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-package-modifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-package-modifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-package-modifier-conc-rep abnf::cst) (cst-package-modifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-import-declaration-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-import-declaration-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-import-declaration-conc1-rep (b* ((abnf::csts (cst-import-declaration-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-rep-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-import-declaration-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "single-type-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-rep-of-tree-fix-cst (equal (cst-import-declaration-conc1-rep (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc1-rep abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc1-rep abnf::cst) (cst-import-declaration-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-import-declaration-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-import-declaration-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-import-declaration-conc2-rep (b* ((abnf::csts (cst-import-declaration-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-rep-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-import-declaration-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "type-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-rep-of-tree-fix-cst (equal (cst-import-declaration-conc2-rep (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc2-rep abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc2-rep abnf::cst) (cst-import-declaration-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-import-declaration-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-import-declaration-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-import-declaration-conc3-rep (b* ((abnf::csts (cst-import-declaration-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-rep-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-import-declaration-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "single-static-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-rep-of-tree-fix-cst (equal (cst-import-declaration-conc3-rep (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc3-rep abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc3-rep abnf::cst) (cst-import-declaration-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-import-declaration-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-import-declaration-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-import-declaration-conc4-rep (b* ((abnf::csts (cst-import-declaration-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-rep-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-import-declaration-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "static-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-rep-of-tree-fix-cst (equal (cst-import-declaration-conc4-rep (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc4-rep abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc4-rep abnf::cst) (cst-import-declaration-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-declaration-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-declaration-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-declaration-conc1-rep (b* ((abnf::csts (cst-class-declaration-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-rep-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-class-declaration-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "normal-class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-rep-of-tree-fix-cst (equal (cst-class-declaration-conc1-rep (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc1-rep abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc1-rep abnf::cst) (cst-class-declaration-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-declaration-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-declaration-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-declaration-conc2-rep (b* ((abnf::csts (cst-class-declaration-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-rep-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-class-declaration-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "enum-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-rep-of-tree-fix-cst (equal (cst-class-declaration-conc2-rep (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc2-rep abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc2-rep abnf::cst) (cst-class-declaration-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-body-declaration-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-body-declaration-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-body-declaration-conc1-rep (b* ((abnf::csts (cst-class-body-declaration-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-rep-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-class-body-declaration-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-member-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-rep-of-tree-fix-cst (equal (cst-class-body-declaration-conc1-rep (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc1-rep abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc1-rep abnf::cst) (cst-class-body-declaration-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-body-declaration-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-body-declaration-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-body-declaration-conc2-rep (b* ((abnf::csts (cst-class-body-declaration-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-rep-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-class-body-declaration-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "instance-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-rep-of-tree-fix-cst (equal (cst-class-body-declaration-conc2-rep (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc2-rep abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc2-rep abnf::cst) (cst-class-body-declaration-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-class-body-declaration-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-body-declaration-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-body-declaration-conc3-rep (b* ((abnf::csts (cst-class-body-declaration-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-rep-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-class-body-declaration-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "static-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-rep-of-tree-fix-cst (equal (cst-class-body-declaration-conc3-rep (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc3-rep abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc3-rep abnf::cst) (cst-class-body-declaration-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-class-body-declaration-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-class-body-declaration-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-class-body-declaration-conc4-rep (b* ((abnf::csts (cst-class-body-declaration-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-rep-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-class-body-declaration-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "constructor-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-rep-of-tree-fix-cst (equal (cst-class-body-declaration-conc4-rep (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc4-rep abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc4-rep abnf::cst) (cst-class-body-declaration-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-initializer-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-variable-initializer-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-variable-initializer-conc1-rep (b* ((abnf::csts (cst-variable-initializer-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-rep-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-variable-initializer-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-rep-of-tree-fix-cst (equal (cst-variable-initializer-conc1-rep (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc1-rep abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc1-rep abnf::cst) (cst-variable-initializer-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-initializer-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-variable-initializer-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-variable-initializer-conc2-rep (b* ((abnf::csts (cst-variable-initializer-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-rep-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-variable-initializer-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-rep-of-tree-fix-cst (equal (cst-variable-initializer-conc2-rep (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc2-rep abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc2-rep abnf::cst) (cst-variable-initializer-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-type-conc1-rep (b* ((abnf::csts (cst-unann-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-unann-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-rep-of-tree-fix-cst (equal (cst-unann-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-unann-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-unann-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc1-rep abnf::cst) (cst-unann-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-type-conc2-rep (b* ((abnf::csts (cst-unann-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-unann-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-rep-of-tree-fix-cst (equal (cst-unann-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-unann-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-unann-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc2-rep abnf::cst) (cst-unann-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-reference-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-reference-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-reference-type-conc1-rep (b* ((abnf::csts (cst-unann-reference-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-unann-reference-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-rep-of-tree-fix-cst (equal (cst-unann-reference-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc1-rep abnf::cst) (cst-unann-reference-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-reference-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-reference-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-reference-type-conc2-rep (b* ((abnf::csts (cst-unann-reference-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-unann-reference-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-rep-of-tree-fix-cst (equal (cst-unann-reference-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc2-rep abnf::cst) (cst-unann-reference-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-unann-reference-type-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-reference-type-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-reference-type-conc3-rep (b* ((abnf::csts (cst-unann-reference-type-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-rep-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-unann-reference-type-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-rep-of-tree-fix-cst (equal (cst-unann-reference-type-conc3-rep (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc3-rep abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc3-rep abnf::cst) (cst-unann-reference-type-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-class-or-interface-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-class-or-interface-type-conc1-rep (b* ((abnf::csts (cst-unann-class-or-interface-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-unann-class-or-interface-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc1-rep abnf::cst) (cst-unann-class-or-interface-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-class-or-interface-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-class-or-interface-type-conc2-rep (b* ((abnf::csts (cst-unann-class-or-interface-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-unann-class-or-interface-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc2-rep abnf::cst) (cst-unann-class-or-interface-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-interface-type-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-interface-type"))) (let ((__function__ 'cst-unann-interface-type-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-interface-type-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-interface-type-conc-rep (b* ((abnf::csts (cst-unann-interface-type-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-rep-match (implies (cst-matchp abnf::cst "unann-interface-type") (b* ((abnf::csts (cst-unann-interface-type-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-rep-of-tree-fix-cst (equal (cst-unann-interface-type-conc-rep (abnf::tree-fix abnf::cst)) (cst-unann-interface-type-conc-rep abnf::cst)))
Theorem:
(defthm cst-unann-interface-type-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-interface-type-conc-rep abnf::cst) (cst-unann-interface-type-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-variable-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-type-variable"))) (let ((__function__ 'cst-unann-type-variable-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-unann-type-variable-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-unann-type-variable-conc-rep (b* ((abnf::csts (cst-unann-type-variable-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-rep-match (implies (cst-matchp abnf::cst "unann-type-variable") (b* ((abnf::csts (cst-unann-type-variable-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-rep-of-tree-fix-cst (equal (cst-unann-type-variable-conc-rep (abnf::tree-fix abnf::cst)) (cst-unann-type-variable-conc-rep abnf::cst)))
Theorem:
(defthm cst-unann-type-variable-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-variable-conc-rep abnf::cst) (cst-unann-type-variable-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-exception-type-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-exception-type-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-exception-type-conc1-rep (b* ((abnf::csts (cst-exception-type-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-rep-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-exception-type-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-rep-of-tree-fix-cst (equal (cst-exception-type-conc1-rep (abnf::tree-fix abnf::cst)) (cst-exception-type-conc1-rep abnf::cst)))
Theorem:
(defthm cst-exception-type-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc1-rep abnf::cst) (cst-exception-type-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-exception-type-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-exception-type-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-exception-type-conc2-rep (b* ((abnf::csts (cst-exception-type-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-rep-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-exception-type-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-rep-of-tree-fix-cst (equal (cst-exception-type-conc2-rep (abnf::tree-fix abnf::cst)) (cst-exception-type-conc2-rep abnf::cst)))
Theorem:
(defthm cst-exception-type-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc2-rep abnf::cst) (cst-exception-type-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-instance-initializer-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "instance-initializer"))) (let ((__function__ 'cst-instance-initializer-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-instance-initializer-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-instance-initializer-conc-rep (b* ((abnf::csts (cst-instance-initializer-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-rep-match (implies (cst-matchp abnf::cst "instance-initializer") (b* ((abnf::csts (cst-instance-initializer-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-rep-of-tree-fix-cst (equal (cst-instance-initializer-conc-rep (abnf::tree-fix abnf::cst)) (cst-instance-initializer-conc-rep abnf::cst)))
Theorem:
(defthm cst-instance-initializer-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-instance-initializer-conc-rep abnf::cst) (cst-instance-initializer-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-simple-type-name-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name"))) (let ((__function__ 'cst-simple-type-name-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-simple-type-name-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-simple-type-name-conc-rep (b* ((abnf::csts (cst-simple-type-name-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-rep-match (implies (cst-matchp abnf::cst "simple-type-name") (b* ((abnf::csts (cst-simple-type-name-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-rep-of-tree-fix-cst (equal (cst-simple-type-name-conc-rep (abnf::tree-fix abnf::cst)) (cst-simple-type-name-conc-rep abnf::cst)))
Theorem:
(defthm cst-simple-type-name-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-simple-type-name-conc-rep abnf::cst) (cst-simple-type-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-constant-modifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier"))) (let ((__function__ 'cst-enum-constant-modifier-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-enum-constant-modifier-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-enum-constant-modifier-conc-rep (b* ((abnf::csts (cst-enum-constant-modifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-match (implies (cst-matchp abnf::cst "enum-constant-modifier") (b* ((abnf::csts (cst-enum-constant-modifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-of-tree-fix-cst (equal (cst-enum-constant-modifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-enum-constant-modifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-constant-modifier-conc-rep abnf::cst) (cst-enum-constant-modifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-interface-declaration-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-interface-declaration-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-interface-declaration-conc1-rep (b* ((abnf::csts (cst-interface-declaration-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-rep-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-interface-declaration-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "normal-interface-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-rep-of-tree-fix-cst (equal (cst-interface-declaration-conc1-rep (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc1-rep abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc1-rep abnf::cst) (cst-interface-declaration-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-interface-declaration-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-interface-declaration-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-interface-declaration-conc2-rep (b* ((abnf::csts (cst-interface-declaration-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-rep-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-interface-declaration-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "annotation-type-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-rep-of-tree-fix-cst (equal (cst-interface-declaration-conc2-rep (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc2-rep abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc2-rep abnf::cst) (cst-interface-declaration-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)))) (let ((__function__ 'cst-annotation-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-annotation-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-annotation-conc1-rep (b* ((abnf::csts (cst-annotation-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-rep-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-annotation-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "normal-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-rep-of-tree-fix-cst (equal (cst-annotation-conc1-rep (abnf::tree-fix abnf::cst)) (cst-annotation-conc1-rep abnf::cst)))
Theorem:
(defthm cst-annotation-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc1-rep abnf::cst) (cst-annotation-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)))) (let ((__function__ 'cst-annotation-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-annotation-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-annotation-conc2-rep (b* ((abnf::csts (cst-annotation-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-rep-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-annotation-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "marker-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-rep-of-tree-fix-cst (equal (cst-annotation-conc2-rep (abnf::tree-fix abnf::cst)) (cst-annotation-conc2-rep abnf::cst)))
Theorem:
(defthm cst-annotation-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc2-rep abnf::cst) (cst-annotation-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)))) (let ((__function__ 'cst-annotation-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-annotation-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-annotation-conc3-rep (b* ((abnf::csts (cst-annotation-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-rep-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-annotation-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "single-element-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-rep-of-tree-fix-cst (equal (cst-annotation-conc3-rep (abnf::tree-fix abnf::cst)) (cst-annotation-conc3-rep abnf::cst)))
Theorem:
(defthm cst-annotation-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc3-rep abnf::cst) (cst-annotation-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)))) (let ((__function__ 'cst-element-value-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-element-value-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-element-value-conc1-rep (b* ((abnf::csts (cst-element-value-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-rep-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-element-value-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-rep-of-tree-fix-cst (equal (cst-element-value-conc1-rep (abnf::tree-fix abnf::cst)) (cst-element-value-conc1-rep abnf::cst)))
Theorem:
(defthm cst-element-value-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc1-rep abnf::cst) (cst-element-value-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)))) (let ((__function__ 'cst-element-value-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-element-value-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-element-value-conc2-rep (b* ((abnf::csts (cst-element-value-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-rep-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-element-value-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "element-value-array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-rep-of-tree-fix-cst (equal (cst-element-value-conc2-rep (abnf::tree-fix abnf::cst)) (cst-element-value-conc2-rep abnf::cst)))
Theorem:
(defthm cst-element-value-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc2-rep abnf::cst) (cst-element-value-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)))) (let ((__function__ 'cst-element-value-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-element-value-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-element-value-conc3-rep (b* ((abnf::csts (cst-element-value-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-rep-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-element-value-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-rep-of-tree-fix-cst (equal (cst-element-value-conc3-rep (abnf::tree-fix abnf::cst)) (cst-element-value-conc3-rep abnf::cst)))
Theorem:
(defthm cst-element-value-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc3-rep abnf::cst) (cst-element-value-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-block-statement-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-block-statement-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-block-statement-conc1-rep (b* ((abnf::csts (cst-block-statement-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-rep-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-block-statement-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "local-variable-declaration-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-rep-of-tree-fix-cst (equal (cst-block-statement-conc1-rep (abnf::tree-fix abnf::cst)) (cst-block-statement-conc1-rep abnf::cst)))
Theorem:
(defthm cst-block-statement-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc1-rep abnf::cst) (cst-block-statement-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-block-statement-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-block-statement-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-block-statement-conc2-rep (b* ((abnf::csts (cst-block-statement-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-rep-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-block-statement-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-rep-of-tree-fix-cst (equal (cst-block-statement-conc2-rep (abnf::tree-fix abnf::cst)) (cst-block-statement-conc2-rep abnf::cst)))
Theorem:
(defthm cst-block-statement-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc2-rep abnf::cst) (cst-block-statement-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-block-statement-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-block-statement-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-block-statement-conc3-rep (b* ((abnf::csts (cst-block-statement-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-rep-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-block-statement-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-rep-of-tree-fix-cst (equal (cst-block-statement-conc3-rep (abnf::tree-fix abnf::cst)) (cst-block-statement-conc3-rep abnf::cst)))
Theorem:
(defthm cst-block-statement-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc3-rep abnf::cst) (cst-block-statement-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc1-rep (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-of-tree-fix-cst (equal (cst-statement-conc1-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc1-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc1-rep abnf::cst) (cst-statement-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc2-rep (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "labeled-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-of-tree-fix-cst (equal (cst-statement-conc2-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc2-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc2-rep abnf::cst) (cst-statement-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc3-rep (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "if-then-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-of-tree-fix-cst (equal (cst-statement-conc3-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc3-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc3-rep abnf::cst) (cst-statement-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc4-rep (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "if-then-else-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-of-tree-fix-cst (equal (cst-statement-conc4-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc4-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc4-rep abnf::cst) (cst-statement-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc5-rep (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "while-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-of-tree-fix-cst (equal (cst-statement-conc5-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc5-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc5-rep abnf::cst) (cst-statement-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc6-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-conc6-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc6 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc6-rep (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-of-tree-fix-cst (equal (cst-statement-conc6-rep (abnf::tree-fix abnf::cst)) (cst-statement-conc6-rep abnf::cst)))
Theorem:
(defthm cst-statement-conc6-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc6-rep abnf::cst) (cst-statement-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-no-short-if-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-no-short-if-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-no-short-if-conc1-rep (b* ((abnf::csts (cst-statement-no-short-if-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-statement-no-short-if-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-of-tree-fix-cst (equal (cst-statement-no-short-if-conc1-rep (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc1-rep abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc1-rep abnf::cst) (cst-statement-no-short-if-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-no-short-if-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-no-short-if-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-no-short-if-conc2-rep (b* ((abnf::csts (cst-statement-no-short-if-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-statement-no-short-if-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "labeled-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-of-tree-fix-cst (equal (cst-statement-no-short-if-conc2-rep (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc2-rep abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc2-rep abnf::cst) (cst-statement-no-short-if-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-no-short-if-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-no-short-if-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-no-short-if-conc3-rep (b* ((abnf::csts (cst-statement-no-short-if-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-statement-no-short-if-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "if-then-else-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-of-tree-fix-cst (equal (cst-statement-no-short-if-conc3-rep (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc3-rep abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc3-rep abnf::cst) (cst-statement-no-short-if-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-no-short-if-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-no-short-if-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-no-short-if-conc4-rep (b* ((abnf::csts (cst-statement-no-short-if-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-statement-no-short-if-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "while-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-of-tree-fix-cst (equal (cst-statement-no-short-if-conc4-rep (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc4-rep abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc4-rep abnf::cst) (cst-statement-no-short-if-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-no-short-if-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-no-short-if-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-no-short-if-conc5-rep (b* ((abnf::csts (cst-statement-no-short-if-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-statement-no-short-if-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-of-tree-fix-cst (equal (cst-statement-no-short-if-conc5-rep (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc5-rep abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc5-rep abnf::cst) (cst-statement-no-short-if-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc1-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc1-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc1-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc1-rep abnf::cst) (cst-statement-without-trailing-substatement-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc2-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "empty-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc2-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc2-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc2-rep abnf::cst) (cst-statement-without-trailing-substatement-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc3-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc3-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc3-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc3-rep abnf::cst) (cst-statement-without-trailing-substatement-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc4-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "assert-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc4-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc4-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc4-rep abnf::cst) (cst-statement-without-trailing-substatement-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc5-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "switch-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc5-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc5-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc5-rep abnf::cst) (cst-statement-without-trailing-substatement-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc6-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc6-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc6 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc6-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc6-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc6-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "do-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc6-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc6-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc6-rep abnf::cst) (cst-statement-without-trailing-substatement-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc7-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc7-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc7 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc7-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc7-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc7-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "break-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc7-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc7-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc7-rep abnf::cst) (cst-statement-without-trailing-substatement-conc7-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc8-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc8-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc8 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc8-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc8-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc8-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "continue-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc8-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc8-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc8-rep abnf::cst) (cst-statement-without-trailing-substatement-conc8-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc9-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc9-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc9 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc9-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc9-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc9-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "return-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc9-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc9-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc9-rep abnf::cst) (cst-statement-without-trailing-substatement-conc9-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc10-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc10-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc10 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc10-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc10-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc10-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "synchronized-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc10-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc10-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc10-rep abnf::cst) (cst-statement-without-trailing-substatement-conc10-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc11-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc11-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc11 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc11-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc11-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc11-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "throw-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc11-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc11-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc11-rep abnf::cst) (cst-statement-without-trailing-substatement-conc11-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc12-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc12-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc12 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc12-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc12-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc12-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "try-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc12-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc12-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc12-rep abnf::cst) (cst-statement-without-trailing-substatement-conc12-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc13-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc13-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-without-trailing-substatement-conc13 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-without-trailing-substatement-conc13-rep (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc13-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)) (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc13-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "yield-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc13-rep (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc13-rep abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc13-rep abnf::cst) (cst-statement-without-trailing-substatement-conc13-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-empty-statement-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "empty-statement"))) (let ((__function__ 'cst-empty-statement-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-empty-statement-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-empty-statement-conc-rep (b* ((abnf::csts (cst-empty-statement-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-empty-statement-conc-rep-match (implies (cst-matchp abnf::cst "empty-statement") (b* ((abnf::csts (cst-empty-statement-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "\";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-empty-statement-conc-rep-of-tree-fix-cst (equal (cst-empty-statement-conc-rep (abnf::tree-fix abnf::cst)) (cst-empty-statement-conc-rep abnf::cst)))
Theorem:
(defthm cst-empty-statement-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-empty-statement-conc-rep abnf::cst) (cst-empty-statement-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-expression-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc1-rep (b* ((abnf::csts (cst-statement-expression-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-statement-expression-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-rep-of-tree-fix-cst (equal (cst-statement-expression-conc1-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc1-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc1-rep abnf::cst) (cst-statement-expression-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-expression-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc2-rep (b* ((abnf::csts (cst-statement-expression-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-statement-expression-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "pre-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-rep-of-tree-fix-cst (equal (cst-statement-expression-conc2-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc2-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc2-rep abnf::cst) (cst-statement-expression-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-expression-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc3-rep (b* ((abnf::csts (cst-statement-expression-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-statement-expression-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "pre-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-rep-of-tree-fix-cst (equal (cst-statement-expression-conc3-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc3-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc3-rep abnf::cst) (cst-statement-expression-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-expression-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc4-rep (b* ((abnf::csts (cst-statement-expression-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-statement-expression-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-rep-of-tree-fix-cst (equal (cst-statement-expression-conc4-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc4-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc4-rep abnf::cst) (cst-statement-expression-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-expression-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc5-rep (b* ((abnf::csts (cst-statement-expression-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-statement-expression-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-rep-of-tree-fix-cst (equal (cst-statement-expression-conc5-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc5-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc5-rep abnf::cst) (cst-statement-expression-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc6-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-expression-conc6-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc6 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc6-rep (b* ((abnf::csts (cst-statement-expression-conc6-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)) (b* ((abnf::csts (cst-statement-expression-conc6-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "method-invocation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-rep-of-tree-fix-cst (equal (cst-statement-expression-conc6-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc6-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc6-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc6-rep abnf::cst) (cst-statement-expression-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc7-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-expression-conc7-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-expression-conc7 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-expression-conc7-rep (b* ((abnf::csts (cst-statement-expression-conc7-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-rep-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)) (b* ((abnf::csts (cst-statement-expression-conc7-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "class-instance-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-rep-of-tree-fix-cst (equal (cst-statement-expression-conc7-rep (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc7-rep abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc7-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc7-rep abnf::cst) (cst-statement-expression-conc7-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-case-constant-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "case-constant"))) (let ((__function__ 'cst-case-constant-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-case-constant-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-case-constant-conc-rep (b* ((abnf::csts (cst-case-constant-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-rep-match (implies (cst-matchp abnf::cst "case-constant") (b* ((abnf::csts (cst-case-constant-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-rep-of-tree-fix-cst (equal (cst-case-constant-conc-rep (abnf::tree-fix abnf::cst)) (cst-case-constant-conc-rep abnf::cst)))
Theorem:
(defthm cst-case-constant-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-case-constant-conc-rep abnf::cst) (cst-case-constant-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-statement-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-statement-conc1-rep (b* ((abnf::csts (cst-for-statement-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-rep-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-for-statement-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-rep-of-tree-fix-cst (equal (cst-for-statement-conc1-rep (abnf::tree-fix abnf::cst)) (cst-for-statement-conc1-rep abnf::cst)))
Theorem:
(defthm cst-for-statement-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc1-rep abnf::cst) (cst-for-statement-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-statement-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-statement-conc2-rep (b* ((abnf::csts (cst-for-statement-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-rep-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-for-statement-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "enhanced-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-rep-of-tree-fix-cst (equal (cst-for-statement-conc2-rep (abnf::tree-fix abnf::cst)) (cst-for-statement-conc2-rep abnf::cst)))
Theorem:
(defthm cst-for-statement-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc2-rep abnf::cst) (cst-for-statement-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-no-short-if-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-statement-no-short-if-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-statement-no-short-if-conc1-rep (b* ((abnf::csts (cst-for-statement-no-short-if-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-for-statement-no-short-if-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc1-rep (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc1-rep abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc1-rep abnf::cst) (cst-for-statement-no-short-if-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-no-short-if-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-statement-no-short-if-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-statement-no-short-if-conc2-rep (b* ((abnf::csts (cst-for-statement-no-short-if-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-for-statement-no-short-if-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "enhanced-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc2-rep (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc2-rep abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc2-rep abnf::cst) (cst-for-statement-no-short-if-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-init-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-init-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-init-conc1-rep (b* ((abnf::csts (cst-for-init-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-rep-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-for-init-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-rep-of-tree-fix-cst (equal (cst-for-init-conc1-rep (abnf::tree-fix abnf::cst)) (cst-for-init-conc1-rep abnf::cst)))
Theorem:
(defthm cst-for-init-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc1-rep abnf::cst) (cst-for-init-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-init-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-init-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-init-conc2-rep (b* ((abnf::csts (cst-for-init-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-rep-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-for-init-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "local-variable-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-rep-of-tree-fix-cst (equal (cst-for-init-conc2-rep (abnf::tree-fix abnf::cst)) (cst-for-init-conc2-rep abnf::cst)))
Theorem:
(defthm cst-for-init-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc2-rep abnf::cst) (cst-for-init-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-update-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-update"))) (let ((__function__ 'cst-for-update-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-for-update-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-for-update-conc-rep (b* ((abnf::csts (cst-for-update-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-rep-match (implies (cst-matchp abnf::cst "for-update") (b* ((abnf::csts (cst-for-update-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-rep-of-tree-fix-cst (equal (cst-for-update-conc-rep (abnf::tree-fix abnf::cst)) (cst-for-update-conc-rep abnf::cst)))
Theorem:
(defthm cst-for-update-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-update-conc-rep abnf::cst) (cst-for-update-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-access-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-variable-access-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-variable-access-conc1-rep (b* ((abnf::csts (cst-variable-access-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-rep-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-variable-access-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-rep-of-tree-fix-cst (equal (cst-variable-access-conc1-rep (abnf::tree-fix abnf::cst)) (cst-variable-access-conc1-rep abnf::cst)))
Theorem:
(defthm cst-variable-access-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc1-rep abnf::cst) (cst-variable-access-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-access-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-variable-access-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-variable-access-conc2-rep (b* ((abnf::csts (cst-variable-access-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-rep-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-variable-access-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-rep-of-tree-fix-cst (equal (cst-variable-access-conc2-rep (abnf::tree-fix abnf::cst)) (cst-variable-access-conc2-rep abnf::cst)))
Theorem:
(defthm cst-variable-access-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc2-rep abnf::cst) (cst-variable-access-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-expression-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-expression-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-expression-conc1-rep (b* ((abnf::csts (cst-expression-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-rep-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-expression-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "lambda-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-rep-of-tree-fix-cst (equal (cst-expression-conc1-rep (abnf::tree-fix abnf::cst)) (cst-expression-conc1-rep abnf::cst)))
Theorem:
(defthm cst-expression-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc1-rep abnf::cst) (cst-expression-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-expression-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-expression-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-expression-conc2-rep (b* ((abnf::csts (cst-expression-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-rep-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-expression-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "assignment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-rep-of-tree-fix-cst (equal (cst-expression-conc2-rep (abnf::tree-fix abnf::cst)) (cst-expression-conc2-rep abnf::cst)))
Theorem:
(defthm cst-expression-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc2-rep abnf::cst) (cst-expression-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)))) (let ((__function__ 'cst-primary-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-primary-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-primary-conc1-rep (b* ((abnf::csts (cst-primary-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-rep-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-primary-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "primary-no-new-array"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-rep-of-tree-fix-cst (equal (cst-primary-conc1-rep (abnf::tree-fix abnf::cst)) (cst-primary-conc1-rep abnf::cst)))
Theorem:
(defthm cst-primary-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc1-rep abnf::cst) (cst-primary-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)))) (let ((__function__ 'cst-primary-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-primary-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-primary-conc2-rep (b* ((abnf::csts (cst-primary-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-rep-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-primary-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "array-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-rep-of-tree-fix-cst (equal (cst-primary-conc2-rep (abnf::tree-fix abnf::cst)) (cst-primary-conc2-rep abnf::cst)))
Theorem:
(defthm cst-primary-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc2-rep abnf::cst) (cst-primary-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-postfix-expression-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-postfix-expression-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-postfix-expression-conc1-rep (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-rep-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "primary"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-rep-of-tree-fix-cst (equal (cst-postfix-expression-conc1-rep (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc1-rep abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc1-rep abnf::cst) (cst-postfix-expression-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-postfix-expression-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-postfix-expression-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-postfix-expression-conc2-rep (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-rep-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-rep-of-tree-fix-cst (equal (cst-postfix-expression-conc2-rep (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc2-rep abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc2-rep abnf::cst) (cst-postfix-expression-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-postfix-expression-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-postfix-expression-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-postfix-expression-conc3-rep (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-rep-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-rep-of-tree-fix-cst (equal (cst-postfix-expression-conc3-rep (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc3-rep abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc3-rep abnf::cst) (cst-postfix-expression-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-postfix-expression-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-postfix-expression-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-postfix-expression-conc4-rep (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-rep-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-rep-of-tree-fix-cst (equal (cst-postfix-expression-conc4-rep (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc4-rep abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc4-rep abnf::cst) (cst-postfix-expression-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-assignment-expression-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-assignment-expression-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-assignment-expression-conc1-rep (b* ((abnf::csts (cst-assignment-expression-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-rep-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-assignment-expression-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-rep-of-tree-fix-cst (equal (cst-assignment-expression-conc1-rep (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc1-rep abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc1-rep abnf::cst) (cst-assignment-expression-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-assignment-expression-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-assignment-expression-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-assignment-expression-conc2-rep (b* ((abnf::csts (cst-assignment-expression-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-rep-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-assignment-expression-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-rep-of-tree-fix-cst (equal (cst-assignment-expression-conc2-rep (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc2-rep abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc2-rep abnf::cst) (cst-assignment-expression-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)))) (let ((__function__ 'cst-left-hand-side-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-left-hand-side-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-left-hand-side-conc1-rep (b* ((abnf::csts (cst-left-hand-side-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-rep-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-left-hand-side-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-rep-of-tree-fix-cst (equal (cst-left-hand-side-conc1-rep (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc1-rep abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc1-rep abnf::cst) (cst-left-hand-side-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)))) (let ((__function__ 'cst-left-hand-side-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-left-hand-side-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-left-hand-side-conc2-rep (b* ((abnf::csts (cst-left-hand-side-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-rep-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-left-hand-side-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-rep-of-tree-fix-cst (equal (cst-left-hand-side-conc2-rep (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc2-rep abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc2-rep abnf::cst) (cst-left-hand-side-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)))) (let ((__function__ 'cst-left-hand-side-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-left-hand-side-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-left-hand-side-conc3-rep (b* ((abnf::csts (cst-left-hand-side-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-rep-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-left-hand-side-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "array-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-rep-of-tree-fix-cst (equal (cst-left-hand-side-conc3-rep (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc3-rep abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc3-rep abnf::cst) (cst-left-hand-side-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)))) (let ((__function__ 'cst-lambda-body-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-lambda-body-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-lambda-body-conc1-rep (b* ((abnf::csts (cst-lambda-body-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-rep-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-lambda-body-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-rep-of-tree-fix-cst (equal (cst-lambda-body-conc1-rep (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc1-rep abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc1-rep abnf::cst) (cst-lambda-body-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)))) (let ((__function__ 'cst-lambda-body-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-lambda-body-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-lambda-body-conc2-rep (b* ((abnf::csts (cst-lambda-body-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-rep-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-lambda-body-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-rep-of-tree-fix-cst (equal (cst-lambda-body-conc2-rep (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc2-rep abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc2-rep abnf::cst) (cst-lambda-body-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-expression-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-constant-expression-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-constant-expression-conc-rep (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-of-tree-fix-cst (equal (cst-constant-expression-conc-rep (abnf::tree-fix abnf::cst)) (cst-constant-expression-conc-rep abnf::cst)))
Theorem:
(defthm cst-constant-expression-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-expression-conc-rep abnf::cst) (cst-constant-expression-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-input-character-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unicode-input-character-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unicode-input-character-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unicode-input-character-conc1-rep-elem (b* ((abnf::cst1 (cst-unicode-input-character-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-unicode-input-character-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unicode-escape"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc1-rep-elem-of-tree-fix-cst (equal (cst-unicode-input-character-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc1-rep-elem abnf::cst) (cst-unicode-input-character-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unicode-input-character-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unicode-input-character-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unicode-input-character-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unicode-input-character-conc2-rep-elem (b* ((abnf::cst1 (cst-unicode-input-character-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "unicode-input-character") (equal (cst-unicode-input-character-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-unicode-input-character-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unicode-input-character-conc2-rep-elem-of-tree-fix-cst (equal (cst-unicode-input-character-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-unicode-input-character-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-unicode-input-character-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unicode-input-character-conc2-rep-elem abnf::cst) (cst-unicode-input-character-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-character-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "input-character"))) (let ((__function__ 'cst-input-character-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-input-character-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-input-character-conc-rep-elem (b* ((abnf::cst1 (cst-input-character-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-rep-elem-match (implies (cst-matchp abnf::cst "input-character") (b* ((abnf::cst1 (cst-input-character-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unicode-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-character-conc-rep-elem-of-tree-fix-cst (equal (cst-input-character-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-input-character-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-input-character-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-character-conc-rep-elem abnf::cst) (cst-input-character-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)))) (let ((__function__ 'cst-input-element-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-input-element-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-input-element-conc1-rep-elem (b* ((abnf::cst1 (cst-input-element-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-input-element-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc1-rep-elem-of-tree-fix-cst (equal (cst-input-element-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-input-element-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-input-element-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc1-rep-elem abnf::cst) (cst-input-element-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)))) (let ((__function__ 'cst-input-element-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-input-element-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-input-element-conc2-rep-elem (b* ((abnf::cst1 (cst-input-element-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-input-element-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc2-rep-elem-of-tree-fix-cst (equal (cst-input-element-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-input-element-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-input-element-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc2-rep-elem abnf::cst) (cst-input-element-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-input-element-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)))) (let ((__function__ 'cst-input-element-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-input-element-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-input-element-conc3-rep-elem (b* ((abnf::cst1 (cst-input-element-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "input-element") (equal (cst-input-element-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-input-element-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-input-element-conc3-rep-elem-of-tree-fix-cst (equal (cst-input-element-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-input-element-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-input-element-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-input-element-conc3-rep-elem abnf::cst) (cst-input-element-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc1-rep-elem (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-elem-of-tree-fix-cst (equal (cst-token-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc1-rep-elem abnf::cst) (cst-token-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)))) (let ((__function__ 'cst-token-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc2-rep-elem (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "keyword"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-elem-of-tree-fix-cst (equal (cst-token-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc2-rep-elem abnf::cst) (cst-token-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)))) (let ((__function__ 'cst-token-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc3-rep-elem (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-elem-of-tree-fix-cst (equal (cst-token-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc3-rep-elem abnf::cst) (cst-token-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)))) (let ((__function__ 'cst-token-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc4-rep-elem (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "separator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-elem-of-tree-fix-cst (equal (cst-token-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4-rep-elem abnf::cst) (cst-token-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc5-rep-elem (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "operator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-elem-of-tree-fix-cst (equal (cst-token-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5-rep-elem abnf::cst) (cst-token-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-comment-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-comment-conc1-rep-elem (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "traditional-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-elem-of-tree-fix-cst (equal (cst-comment-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-comment-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-comment-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc1-rep-elem abnf::cst) (cst-comment-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-comment-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)))) (let ((__function__ 'cst-comment-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-comment-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-comment-conc2-rep-elem (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "end-of-line-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-elem-of-tree-fix-cst (equal (cst-comment-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-comment-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-comment-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-comment-conc2-rep-elem abnf::cst) (cst-comment-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-not-star-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-not-star-conc1-rep-elem (b* ((abnf::cst1 (cst-not-star-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-not-star-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc1-rep-elem-of-tree-fix-cst (equal (cst-not-star-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-not-star-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc1-rep-elem abnf::cst) (cst-not-star-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-not-star-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-not-star-conc2-rep-elem (b* ((abnf::cst1 (cst-not-star-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "not-star") (equal (cst-not-star-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-not-star-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-conc2-rep-elem-of-tree-fix-cst (equal (cst-not-star-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-not-star-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-conc2-rep-elem abnf::cst) (cst-not-star-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-not-star-not-slash-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-not-star-not-slash-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-not-star-not-slash-conc1-rep-elem (b* ((abnf::cst1 (cst-not-star-not-slash-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-not-star-not-slash-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-elem-of-tree-fix-cst (equal (cst-not-star-not-slash-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc1-rep-elem abnf::cst) (cst-not-star-not-slash-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-not-star-not-slash-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-not-star-not-slash-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-not-star-not-slash-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-not-star-not-slash-conc2-rep-elem (b* ((abnf::cst1 (cst-not-star-not-slash-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "not-star-not-slash") (equal (cst-not-star-not-slash-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-not-star-not-slash-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "line-terminator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-elem-of-tree-fix-cst (equal (cst-not-star-not-slash-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-not-star-not-slash-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-not-star-not-slash-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-not-star-not-slash-conc2-rep-elem abnf::cst) (cst-not-star-not-slash-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier"))) (let ((__function__ 'cst-identifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-identifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-identifier-conc-rep-elem (b* ((abnf::cst1 (cst-identifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "identifier") (b* ((abnf::cst1 (cst-identifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier-chars"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-conc-rep-elem-of-tree-fix-cst (equal (cst-identifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-identifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-identifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-conc-rep-elem abnf::cst) (cst-identifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter"))) (let ((__function__ 'cst-java-letter-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-java-letter-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-java-letter-conc-rep-elem (b* ((abnf::cst1 (cst-java-letter-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-rep-elem-match (implies (cst-matchp abnf::cst "java-letter") (b* ((abnf::cst1 (cst-java-letter-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-conc-rep-elem-of-tree-fix-cst (equal (cst-java-letter-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-java-letter-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-java-letter-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-conc-rep-elem abnf::cst) (cst-java-letter-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-java-letter-or-digit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit"))) (let ((__function__ 'cst-java-letter-or-digit-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-java-letter-or-digit-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-java-letter-or-digit-conc-rep-elem (b* ((abnf::cst1 (cst-java-letter-or-digit-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-elem-match (implies (cst-matchp abnf::cst "java-letter-or-digit") (b* ((abnf::cst1 (cst-java-letter-or-digit-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "raw-input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-elem-of-tree-fix-cst (equal (cst-java-letter-or-digit-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-java-letter-or-digit-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-java-letter-or-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-java-letter-or-digit-conc-rep-elem abnf::cst) (cst-java-letter-or-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-identifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-identifier"))) (let ((__function__ 'cst-type-identifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-identifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-identifier-conc-rep-elem (b* ((abnf::cst1 (cst-type-identifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "type-identifier") (b* ((abnf::cst1 (cst-type-identifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-identifier-conc-rep-elem-of-tree-fix-cst (equal (cst-type-identifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-identifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-identifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-identifier-conc-rep-elem abnf::cst) (cst-type-identifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unqualified-method-identifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unqualified-method-identifier"))) (let ((__function__ 'cst-unqualified-method-identifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unqualified-method-identifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unqualified-method-identifier-conc-rep-elem (b* ((abnf::cst1 (cst-unqualified-method-identifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "unqualified-method-identifier") (b* ((abnf::cst1 (cst-unqualified-method-identifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-elem-of-tree-fix-cst (equal (cst-unqualified-method-identifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-unqualified-method-identifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-unqualified-method-identifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unqualified-method-identifier-conc-rep-elem abnf::cst) (cst-unqualified-method-identifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-literal-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc1-rep-elem (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc1-rep-elem-of-tree-fix-cst (equal (cst-literal-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc1-rep-elem abnf::cst) (cst-literal-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-literal-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc2-rep-elem (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc2-rep-elem-of-tree-fix-cst (equal (cst-literal-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc2-rep-elem abnf::cst) (cst-literal-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-literal-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc3-rep-elem (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "boolean-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc3-rep-elem-of-tree-fix-cst (equal (cst-literal-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc3-rep-elem abnf::cst) (cst-literal-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-literal-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc4-rep-elem (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "character-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc4-rep-elem-of-tree-fix-cst (equal (cst-literal-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc4-rep-elem abnf::cst) (cst-literal-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)))) (let ((__function__ 'cst-literal-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc5-rep-elem (b* ((abnf::cst1 (cst-literal-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-literal-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc5-rep-elem-of-tree-fix-cst (equal (cst-literal-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc5-rep-elem abnf::cst) (cst-literal-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-literal-conc6-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)))) (let ((__function__ 'cst-literal-conc6-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-literal-conc6-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-literal-conc6-rep-elem (b* ((abnf::cst1 (cst-literal-conc6-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-rep-elem-match (implies (and (cst-matchp abnf::cst "literal") (equal (cst-literal-conc? abnf::cst) 6)) (b* ((abnf::cst1 (cst-literal-conc6-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "null-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-literal-conc6-rep-elem-of-tree-fix-cst (equal (cst-literal-conc6-rep-elem (abnf::tree-fix abnf::cst)) (cst-literal-conc6-rep-elem abnf::cst)))
Theorem:
(defthm cst-literal-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-literal-conc6-rep-elem abnf::cst) (cst-literal-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-integer-literal-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-integer-literal-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-integer-literal-conc1-rep-elem (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "decimal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc1-rep-elem-of-tree-fix-cst (equal (cst-integer-literal-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc1-rep-elem abnf::cst) (cst-integer-literal-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-integer-literal-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-integer-literal-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-integer-literal-conc2-rep-elem (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "hex-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc2-rep-elem-of-tree-fix-cst (equal (cst-integer-literal-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc2-rep-elem abnf::cst) (cst-integer-literal-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)))) (let ((__function__ 'cst-integer-literal-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-integer-literal-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-integer-literal-conc3-rep-elem (b* ((abnf::cst1 (cst-integer-literal-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-integer-literal-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "octal-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc3-rep-elem-of-tree-fix-cst (equal (cst-integer-literal-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc3-rep-elem abnf::cst) (cst-integer-literal-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-integer-literal-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)))) (let ((__function__ 'cst-integer-literal-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-integer-literal-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-integer-literal-conc4-rep-elem (b* ((abnf::cst1 (cst-integer-literal-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "integer-literal") (equal (cst-integer-literal-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-integer-literal-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "binary-integer-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-integer-literal-conc4-rep-elem-of-tree-fix-cst (equal (cst-integer-literal-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-integer-literal-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-integer-literal-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-integer-literal-conc4-rep-elem abnf::cst) (cst-integer-literal-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-point-literal-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-floating-point-literal-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-floating-point-literal-conc1-rep-elem (b* ((abnf::cst1 (cst-floating-point-literal-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-floating-point-literal-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "decimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc1-rep-elem-of-tree-fix-cst (equal (cst-floating-point-literal-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc1-rep-elem abnf::cst) (cst-floating-point-literal-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-point-literal-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-point-literal-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-floating-point-literal-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-floating-point-literal-conc2-rep-elem (b* ((abnf::cst1 (cst-floating-point-literal-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "floating-point-literal") (equal (cst-floating-point-literal-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-floating-point-literal-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "hexadecimal-floating-point-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-point-literal-conc2-rep-elem-of-tree-fix-cst (equal (cst-floating-point-literal-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-floating-point-literal-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-floating-point-literal-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-point-literal-conc2-rep-elem abnf::cst) (cst-floating-point-literal-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-single-character-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "single-character"))) (let ((__function__ 'cst-single-character-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-single-character-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-single-character-conc-rep-elem (b* ((abnf::cst1 (cst-single-character-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-rep-elem-match (implies (cst-matchp abnf::cst "single-character") (b* ((abnf::cst1 (cst-single-character-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-single-character-conc-rep-elem-of-tree-fix-cst (equal (cst-single-character-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-single-character-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-single-character-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-single-character-conc-rep-elem abnf::cst) (cst-single-character-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-string-character-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-string-character-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-string-character-conc1-rep-elem (b* ((abnf::cst1 (cst-string-character-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-string-character-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "input-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc1-rep-elem-of-tree-fix-cst (equal (cst-string-character-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-string-character-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-string-character-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc1-rep-elem abnf::cst) (cst-string-character-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-character-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-string-character-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-string-character-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-string-character-conc2-rep-elem (b* ((abnf::cst1 (cst-string-character-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "string-character") (equal (cst-string-character-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-string-character-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-character-conc2-rep-elem-of-tree-fix-cst (equal (cst-string-character-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-string-character-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-string-character-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-character-conc2-rep-elem abnf::cst) (cst-string-character-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-conc1-rep-elem (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc1-rep-elem abnf::cst) (cst-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-conc2-rep-elem (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "type") (equal (cst-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-conc2-rep-elem abnf::cst) (cst-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-numeric-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-numeric-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-numeric-type-conc1-rep-elem (b* ((abnf::cst1 (cst-numeric-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-numeric-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "integral-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-numeric-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc1-rep-elem abnf::cst) (cst-numeric-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-numeric-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-numeric-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-numeric-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-numeric-type-conc2-rep-elem (b* ((abnf::cst1 (cst-numeric-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "numeric-type") (equal (cst-numeric-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-numeric-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "floating-point-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-numeric-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-numeric-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-numeric-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-numeric-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-numeric-type-conc2-rep-elem abnf::cst) (cst-numeric-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-reference-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-reference-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-reference-type-conc1-rep-elem (b* ((abnf::cst1 (cst-reference-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-reference-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-reference-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-reference-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc1-rep-elem abnf::cst) (cst-reference-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-reference-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-reference-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-reference-type-conc2-rep-elem (b* ((abnf::cst1 (cst-reference-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-reference-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-reference-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-reference-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc2-rep-elem abnf::cst) (cst-reference-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-reference-type-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-reference-type-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-reference-type-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-reference-type-conc3-rep-elem (b* ((abnf::cst1 (cst-reference-type-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "reference-type") (equal (cst-reference-type-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-reference-type-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-reference-type-conc3-rep-elem-of-tree-fix-cst (equal (cst-reference-type-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-reference-type-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-reference-type-conc3-rep-elem abnf::cst) (cst-reference-type-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-or-interface-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-or-interface-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-or-interface-type-conc1-rep-elem (b* ((abnf::cst1 (cst-class-or-interface-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-class-or-interface-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-class-or-interface-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc1-rep-elem abnf::cst) (cst-class-or-interface-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-or-interface-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-or-interface-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-or-interface-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-or-interface-type-conc2-rep-elem (b* ((abnf::cst1 (cst-class-or-interface-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "class-or-interface-type") (equal (cst-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-class-or-interface-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-class-or-interface-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-or-interface-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-or-interface-type-conc2-rep-elem abnf::cst) (cst-class-or-interface-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-type-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "interface-type"))) (let ((__function__ 'cst-interface-type-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-interface-type-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-interface-type-conc-rep-elem (b* ((abnf::cst1 (cst-interface-type-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-rep-elem-match (implies (cst-matchp abnf::cst "interface-type") (b* ((abnf::cst1 (cst-interface-type-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-type-conc-rep-elem-of-tree-fix-cst (equal (cst-interface-type-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-interface-type-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-type-conc-rep-elem abnf::cst) (cst-interface-type-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-parameter-modifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier"))) (let ((__function__ 'cst-type-parameter-modifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-parameter-modifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-parameter-modifier-conc-rep-elem (b* ((abnf::cst1 (cst-type-parameter-modifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "type-parameter-modifier") (b* ((abnf::cst1 (cst-type-parameter-modifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-elem-of-tree-fix-cst (equal (cst-type-parameter-modifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-parameter-modifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-parameter-modifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-parameter-modifier-conc-rep-elem abnf::cst) (cst-type-parameter-modifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)))) (let ((__function__ 'cst-type-argument-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-argument-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-argument-conc1-rep-elem (b* ((abnf::cst1 (cst-type-argument-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-type-argument-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc1-rep-elem-of-tree-fix-cst (equal (cst-type-argument-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-argument-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-argument-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc1-rep-elem abnf::cst) (cst-type-argument-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-argument-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)))) (let ((__function__ 'cst-type-argument-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-type-argument-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-type-argument-conc2-rep-elem (b* ((abnf::cst1 (cst-type-argument-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "type-argument") (equal (cst-type-argument-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-type-argument-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "wildcard"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-argument-conc2-rep-elem-of-tree-fix-cst (equal (cst-type-argument-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-type-argument-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-type-argument-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-argument-conc2-rep-elem abnf::cst) (cst-type-argument-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-method-name-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "method-name"))) (let ((__function__ 'cst-method-name-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-method-name-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-method-name-conc-rep-elem (b* ((abnf::cst1 (cst-method-name-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-rep-elem-match (implies (cst-matchp abnf::cst "method-name") (b* ((abnf::cst1 (cst-method-name-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unqualified-method-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-method-name-conc-rep-elem-of-tree-fix-cst (equal (cst-method-name-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-method-name-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-method-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-method-name-conc-rep-elem abnf::cst) (cst-method-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)))) (let ((__function__ 'cst-compilation-unit-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-compilation-unit-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-compilation-unit-conc1-rep-elem (b* ((abnf::cst1 (cst-compilation-unit-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-compilation-unit-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "ordinary-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc1-rep-elem-of-tree-fix-cst (equal (cst-compilation-unit-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc1-rep-elem abnf::cst) (cst-compilation-unit-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-compilation-unit-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)))) (let ((__function__ 'cst-compilation-unit-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-compilation-unit-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-compilation-unit-conc2-rep-elem (b* ((abnf::cst1 (cst-compilation-unit-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "compilation-unit") (equal (cst-compilation-unit-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-compilation-unit-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "modular-compilation-unit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-compilation-unit-conc2-rep-elem-of-tree-fix-cst (equal (cst-compilation-unit-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-compilation-unit-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-compilation-unit-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compilation-unit-conc2-rep-elem abnf::cst) (cst-compilation-unit-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-package-modifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "package-modifier"))) (let ((__function__ 'cst-package-modifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-package-modifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-package-modifier-conc-rep-elem (b* ((abnf::cst1 (cst-package-modifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "package-modifier") (b* ((abnf::cst1 (cst-package-modifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-package-modifier-conc-rep-elem-of-tree-fix-cst (equal (cst-package-modifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-package-modifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-package-modifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-package-modifier-conc-rep-elem abnf::cst) (cst-package-modifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-import-declaration-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-import-declaration-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-import-declaration-conc1-rep-elem (b* ((abnf::cst1 (cst-import-declaration-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-import-declaration-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "single-type-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc1-rep-elem-of-tree-fix-cst (equal (cst-import-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc1-rep-elem abnf::cst) (cst-import-declaration-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-import-declaration-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-import-declaration-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-import-declaration-conc2-rep-elem (b* ((abnf::cst1 (cst-import-declaration-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-import-declaration-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "type-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc2-rep-elem-of-tree-fix-cst (equal (cst-import-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc2-rep-elem abnf::cst) (cst-import-declaration-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-import-declaration-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-import-declaration-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-import-declaration-conc3-rep-elem (b* ((abnf::cst1 (cst-import-declaration-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-import-declaration-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "single-static-import-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc3-rep-elem-of-tree-fix-cst (equal (cst-import-declaration-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc3-rep-elem abnf::cst) (cst-import-declaration-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-import-declaration-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-import-declaration-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-import-declaration-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-import-declaration-conc4-rep-elem (b* ((abnf::cst1 (cst-import-declaration-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "import-declaration") (equal (cst-import-declaration-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-import-declaration-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "static-import-on-demand-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-import-declaration-conc4-rep-elem-of-tree-fix-cst (equal (cst-import-declaration-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-import-declaration-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-import-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-import-declaration-conc4-rep-elem abnf::cst) (cst-import-declaration-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-declaration-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-declaration-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-declaration-conc1-rep-elem (b* ((abnf::cst1 (cst-class-declaration-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-class-declaration-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "normal-class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc1-rep-elem-of-tree-fix-cst (equal (cst-class-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc1-rep-elem abnf::cst) (cst-class-declaration-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-declaration-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-declaration-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-declaration-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-declaration-conc2-rep-elem (b* ((abnf::cst1 (cst-class-declaration-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "class-declaration") (equal (cst-class-declaration-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-class-declaration-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "enum-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-declaration-conc2-rep-elem-of-tree-fix-cst (equal (cst-class-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-declaration-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-declaration-conc2-rep-elem abnf::cst) (cst-class-declaration-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-class-body-declaration-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-body-declaration-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-body-declaration-conc1-rep-elem (b* ((abnf::cst1 (cst-class-body-declaration-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-class-body-declaration-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-member-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc1-rep-elem-of-tree-fix-cst (equal (cst-class-body-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc1-rep-elem abnf::cst) (cst-class-body-declaration-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-class-body-declaration-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-body-declaration-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-body-declaration-conc2-rep-elem (b* ((abnf::cst1 (cst-class-body-declaration-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-class-body-declaration-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "instance-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc2-rep-elem-of-tree-fix-cst (equal (cst-class-body-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc2-rep-elem abnf::cst) (cst-class-body-declaration-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)))) (let ((__function__ 'cst-class-body-declaration-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-body-declaration-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-body-declaration-conc3-rep-elem (b* ((abnf::cst1 (cst-class-body-declaration-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-class-body-declaration-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "static-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc3-rep-elem-of-tree-fix-cst (equal (cst-class-body-declaration-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc3-rep-elem abnf::cst) (cst-class-body-declaration-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-class-body-declaration-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)))) (let ((__function__ 'cst-class-body-declaration-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-class-body-declaration-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-class-body-declaration-conc4-rep-elem (b* ((abnf::cst1 (cst-class-body-declaration-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "class-body-declaration") (equal (cst-class-body-declaration-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-class-body-declaration-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "constructor-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-class-body-declaration-conc4-rep-elem-of-tree-fix-cst (equal (cst-class-body-declaration-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-class-body-declaration-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-class-body-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-class-body-declaration-conc4-rep-elem abnf::cst) (cst-class-body-declaration-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-initializer-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-variable-initializer-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-variable-initializer-conc1-rep-elem (b* ((abnf::cst1 (cst-variable-initializer-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-variable-initializer-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc1-rep-elem-of-tree-fix-cst (equal (cst-variable-initializer-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc1-rep-elem abnf::cst) (cst-variable-initializer-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-initializer-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-initializer-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-variable-initializer-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-variable-initializer-conc2-rep-elem (b* ((abnf::cst1 (cst-variable-initializer-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "variable-initializer") (equal (cst-variable-initializer-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-variable-initializer-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-initializer-conc2-rep-elem-of-tree-fix-cst (equal (cst-variable-initializer-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-variable-initializer-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-variable-initializer-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-initializer-conc2-rep-elem abnf::cst) (cst-variable-initializer-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-type-conc1-rep-elem (b* ((abnf::cst1 (cst-unann-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-unann-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-primitive-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-unann-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc1-rep-elem abnf::cst) (cst-unann-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-type-conc2-rep-elem (b* ((abnf::cst1 (cst-unann-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-type") (equal (cst-unann-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-unann-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-reference-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-unann-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-conc2-rep-elem abnf::cst) (cst-unann-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-reference-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-reference-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-reference-type-conc1-rep-elem (b* ((abnf::cst1 (cst-unann-reference-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-unann-reference-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-class-or-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-unann-reference-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc1-rep-elem abnf::cst) (cst-unann-reference-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-reference-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-reference-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-reference-type-conc2-rep-elem (b* ((abnf::cst1 (cst-unann-reference-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-unann-reference-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-unann-reference-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc2-rep-elem abnf::cst) (cst-unann-reference-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-reference-type-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)))) (let ((__function__ 'cst-unann-reference-type-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-reference-type-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-reference-type-conc3-rep-elem (b* ((abnf::cst1 (cst-unann-reference-type-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-reference-type") (equal (cst-unann-reference-type-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-unann-reference-type-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-array-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-reference-type-conc3-rep-elem-of-tree-fix-cst (equal (cst-unann-reference-type-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-reference-type-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-reference-type-conc3-rep-elem abnf::cst) (cst-unann-reference-type-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-class-or-interface-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-class-or-interface-type-conc1-rep-elem (b* ((abnf::cst1 (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst) (cst-unann-class-or-interface-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-class-or-interface-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-unann-class-or-interface-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-class-or-interface-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-class-or-interface-type-conc2-rep-elem (b* ((abnf::cst1 (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "unann-class-or-interface-type") (equal (cst-unann-class-or-interface-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-interface-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-unann-class-or-interface-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst) (cst-unann-class-or-interface-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-interface-type-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-interface-type"))) (let ((__function__ 'cst-unann-interface-type-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-interface-type-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-interface-type-conc-rep-elem (b* ((abnf::cst1 (cst-unann-interface-type-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-rep-elem-match (implies (cst-matchp abnf::cst "unann-interface-type") (b* ((abnf::cst1 (cst-unann-interface-type-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "unann-class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-interface-type-conc-rep-elem-of-tree-fix-cst (equal (cst-unann-interface-type-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-interface-type-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-interface-type-conc-rep-elem abnf::cst) (cst-unann-interface-type-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unann-type-variable-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unann-type-variable"))) (let ((__function__ 'cst-unann-type-variable-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-unann-type-variable-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-unann-type-variable-conc-rep-elem (b* ((abnf::cst1 (cst-unann-type-variable-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-rep-elem-match (implies (cst-matchp abnf::cst "unann-type-variable") (b* ((abnf::cst1 (cst-unann-type-variable-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-unann-type-variable-conc-rep-elem-of-tree-fix-cst (equal (cst-unann-type-variable-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-unann-type-variable-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-unann-type-variable-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unann-type-variable-conc-rep-elem abnf::cst) (cst-unann-type-variable-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)))) (let ((__function__ 'cst-exception-type-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-exception-type-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-exception-type-conc1-rep-elem (b* ((abnf::cst1 (cst-exception-type-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-exception-type-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-type"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc1-rep-elem-of-tree-fix-cst (equal (cst-exception-type-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-exception-type-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-exception-type-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc1-rep-elem abnf::cst) (cst-exception-type-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exception-type-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)))) (let ((__function__ 'cst-exception-type-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-exception-type-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-exception-type-conc2-rep-elem (b* ((abnf::cst1 (cst-exception-type-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "exception-type") (equal (cst-exception-type-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-exception-type-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "type-variable"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exception-type-conc2-rep-elem-of-tree-fix-cst (equal (cst-exception-type-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-exception-type-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-exception-type-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exception-type-conc2-rep-elem abnf::cst) (cst-exception-type-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-instance-initializer-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "instance-initializer"))) (let ((__function__ 'cst-instance-initializer-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-instance-initializer-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-instance-initializer-conc-rep-elem (b* ((abnf::cst1 (cst-instance-initializer-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-rep-elem-match (implies (cst-matchp abnf::cst "instance-initializer") (b* ((abnf::cst1 (cst-instance-initializer-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-instance-initializer-conc-rep-elem-of-tree-fix-cst (equal (cst-instance-initializer-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-instance-initializer-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-instance-initializer-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-instance-initializer-conc-rep-elem abnf::cst) (cst-instance-initializer-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-simple-type-name-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name"))) (let ((__function__ 'cst-simple-type-name-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-simple-type-name-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-simple-type-name-conc-rep-elem (b* ((abnf::cst1 (cst-simple-type-name-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-rep-elem-match (implies (cst-matchp abnf::cst "simple-type-name") (b* ((abnf::cst1 (cst-simple-type-name-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "type-identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-simple-type-name-conc-rep-elem-of-tree-fix-cst (equal (cst-simple-type-name-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-simple-type-name-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-simple-type-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-simple-type-name-conc-rep-elem abnf::cst) (cst-simple-type-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-constant-modifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier"))) (let ((__function__ 'cst-enum-constant-modifier-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-enum-constant-modifier-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-enum-constant-modifier-conc-rep-elem (b* ((abnf::cst1 (cst-enum-constant-modifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "enum-constant-modifier") (b* ((abnf::cst1 (cst-enum-constant-modifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-elem-of-tree-fix-cst (equal (cst-enum-constant-modifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-enum-constant-modifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-enum-constant-modifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-constant-modifier-conc-rep-elem abnf::cst) (cst-enum-constant-modifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)))) (let ((__function__ 'cst-interface-declaration-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-interface-declaration-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-interface-declaration-conc1-rep-elem (b* ((abnf::cst1 (cst-interface-declaration-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-interface-declaration-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "normal-interface-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc1-rep-elem-of-tree-fix-cst (equal (cst-interface-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc1-rep-elem abnf::cst) (cst-interface-declaration-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-interface-declaration-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)))) (let ((__function__ 'cst-interface-declaration-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-interface-declaration-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-interface-declaration-conc2-rep-elem (b* ((abnf::cst1 (cst-interface-declaration-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "interface-declaration") (equal (cst-interface-declaration-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-interface-declaration-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "annotation-type-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-interface-declaration-conc2-rep-elem-of-tree-fix-cst (equal (cst-interface-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-interface-declaration-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-interface-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-interface-declaration-conc2-rep-elem abnf::cst) (cst-interface-declaration-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)))) (let ((__function__ 'cst-annotation-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-annotation-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-annotation-conc1-rep-elem (b* ((abnf::cst1 (cst-annotation-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-annotation-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "normal-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc1-rep-elem-of-tree-fix-cst (equal (cst-annotation-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-annotation-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-annotation-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc1-rep-elem abnf::cst) (cst-annotation-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)))) (let ((__function__ 'cst-annotation-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-annotation-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-annotation-conc2-rep-elem (b* ((abnf::cst1 (cst-annotation-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-annotation-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "marker-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc2-rep-elem-of-tree-fix-cst (equal (cst-annotation-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-annotation-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-annotation-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc2-rep-elem abnf::cst) (cst-annotation-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-annotation-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)))) (let ((__function__ 'cst-annotation-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-annotation-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-annotation-conc3-rep-elem (b* ((abnf::cst1 (cst-annotation-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "annotation") (equal (cst-annotation-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-annotation-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "single-element-annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-annotation-conc3-rep-elem-of-tree-fix-cst (equal (cst-annotation-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-annotation-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-annotation-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-annotation-conc3-rep-elem abnf::cst) (cst-annotation-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)))) (let ((__function__ 'cst-element-value-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-element-value-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-element-value-conc1-rep-elem (b* ((abnf::cst1 (cst-element-value-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-element-value-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc1-rep-elem-of-tree-fix-cst (equal (cst-element-value-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-element-value-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-element-value-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc1-rep-elem abnf::cst) (cst-element-value-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)))) (let ((__function__ 'cst-element-value-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-element-value-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-element-value-conc2-rep-elem (b* ((abnf::cst1 (cst-element-value-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-element-value-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "element-value-array-initializer"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc2-rep-elem-of-tree-fix-cst (equal (cst-element-value-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-element-value-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-element-value-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc2-rep-elem abnf::cst) (cst-element-value-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-element-value-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)))) (let ((__function__ 'cst-element-value-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-element-value-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-element-value-conc3-rep-elem (b* ((abnf::cst1 (cst-element-value-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "element-value") (equal (cst-element-value-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-element-value-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "annotation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-element-value-conc3-rep-elem-of-tree-fix-cst (equal (cst-element-value-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-element-value-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-element-value-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-element-value-conc3-rep-elem abnf::cst) (cst-element-value-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-block-statement-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-block-statement-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-block-statement-conc1-rep-elem (b* ((abnf::cst1 (cst-block-statement-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-block-statement-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "local-variable-declaration-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc1-rep-elem-of-tree-fix-cst (equal (cst-block-statement-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-block-statement-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-block-statement-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc1-rep-elem abnf::cst) (cst-block-statement-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-block-statement-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-block-statement-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-block-statement-conc2-rep-elem (b* ((abnf::cst1 (cst-block-statement-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-block-statement-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc2-rep-elem-of-tree-fix-cst (equal (cst-block-statement-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-block-statement-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-block-statement-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc2-rep-elem abnf::cst) (cst-block-statement-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-statement-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-block-statement-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-block-statement-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-block-statement-conc3-rep-elem (b* ((abnf::cst1 (cst-block-statement-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "block-statement") (equal (cst-block-statement-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-block-statement-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-statement-conc3-rep-elem-of-tree-fix-cst (equal (cst-block-statement-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-block-statement-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-block-statement-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-statement-conc3-rep-elem abnf::cst) (cst-block-statement-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc1-rep-elem (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-elem-of-tree-fix-cst (equal (cst-statement-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc1-rep-elem abnf::cst) (cst-statement-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc2-rep-elem (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "labeled-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-elem-of-tree-fix-cst (equal (cst-statement-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc2-rep-elem abnf::cst) (cst-statement-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc3-rep-elem (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "if-then-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-elem-of-tree-fix-cst (equal (cst-statement-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc3-rep-elem abnf::cst) (cst-statement-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc4-rep-elem (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "if-then-else-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-elem-of-tree-fix-cst (equal (cst-statement-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc4-rep-elem abnf::cst) (cst-statement-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc5-rep-elem (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "while-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-elem-of-tree-fix-cst (equal (cst-statement-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc5-rep-elem abnf::cst) (cst-statement-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc6-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-conc6-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc6-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc6-rep-elem (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-elem-of-tree-fix-cst (equal (cst-statement-conc6-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-conc6-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-conc6-rep-elem abnf::cst) (cst-statement-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-no-short-if-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-no-short-if-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-no-short-if-conc1-rep-elem (b* ((abnf::cst1 (cst-statement-no-short-if-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-statement-no-short-if-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement-without-trailing-substatement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst (equal (cst-statement-no-short-if-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc1-rep-elem abnf::cst) (cst-statement-no-short-if-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-no-short-if-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-no-short-if-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-no-short-if-conc2-rep-elem (b* ((abnf::cst1 (cst-statement-no-short-if-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-statement-no-short-if-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "labeled-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst (equal (cst-statement-no-short-if-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc2-rep-elem abnf::cst) (cst-statement-no-short-if-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-no-short-if-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-no-short-if-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-no-short-if-conc3-rep-elem (b* ((abnf::cst1 (cst-statement-no-short-if-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-statement-no-short-if-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "if-then-else-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-elem-of-tree-fix-cst (equal (cst-statement-no-short-if-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc3-rep-elem abnf::cst) (cst-statement-no-short-if-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-no-short-if-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-no-short-if-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-no-short-if-conc4-rep-elem (b* ((abnf::cst1 (cst-statement-no-short-if-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-statement-no-short-if-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "while-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-elem-of-tree-fix-cst (equal (cst-statement-no-short-if-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc4-rep-elem abnf::cst) (cst-statement-no-short-if-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-no-short-if-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-no-short-if-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-no-short-if-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-no-short-if-conc5-rep-elem (b* ((abnf::cst1 (cst-statement-no-short-if-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-no-short-if") (equal (cst-statement-no-short-if-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-statement-no-short-if-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-elem-of-tree-fix-cst (equal (cst-statement-no-short-if-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-no-short-if-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-no-short-if-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-no-short-if-conc5-rep-elem abnf::cst) (cst-statement-no-short-if-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc1-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc1-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc2-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "empty-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc2-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc3-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc3-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc4-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "assert-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc4-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc5-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "switch-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc5-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc6-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc6-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc6-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc6-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc6-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 6)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc6-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "do-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc6-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc6-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc6-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc7-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc7-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc7-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc7-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc7-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 7)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc7-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "break-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc7-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc7-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc7-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc7-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc7-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc8-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc8-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc8-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc8-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc8-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 8)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc8-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "continue-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc8-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc8-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc8-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc8-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc8-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc9-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc9-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc9-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc9-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc9-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 9)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc9-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "return-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc9-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc9-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc9-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc9-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc9-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc10-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc10-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc10-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc10-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc10-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 10)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc10-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "synchronized-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc10-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc10-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc10-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc10-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc10-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc11-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc11-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc11-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc11-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc11-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 11)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc11-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "throw-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc11-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc11-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc11-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc11-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc11-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc12-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc12-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc12-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc12-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc12-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 12)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc12-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "try-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc12-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc12-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc12-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc12-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc12-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-without-trailing-substatement-conc13-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)))) (let ((__function__ 'cst-statement-without-trailing-substatement-conc13-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-without-trailing-substatement-conc13-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-without-trailing-substatement-conc13-rep-elem (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc13-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-without-trailing-substatement") (equal (cst-statement-without-trailing-substatement-conc? abnf::cst) 13)) (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc13-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "yield-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-elem-of-tree-fix-cst (equal (cst-statement-without-trailing-substatement-conc13-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-without-trailing-substatement-conc13-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-without-trailing-substatement-conc13-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-without-trailing-substatement-conc13-rep-elem abnf::cst) (cst-statement-without-trailing-substatement-conc13-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-expression-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc1-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-statement-expression-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc1-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc1-rep-elem abnf::cst) (cst-statement-expression-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-statement-expression-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc2-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-statement-expression-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "pre-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc2-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc2-rep-elem abnf::cst) (cst-statement-expression-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-statement-expression-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc3-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-statement-expression-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "pre-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc3-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc3-rep-elem abnf::cst) (cst-statement-expression-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-statement-expression-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc4-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-statement-expression-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc4-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc4-rep-elem abnf::cst) (cst-statement-expression-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)))) (let ((__function__ 'cst-statement-expression-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc5-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-statement-expression-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc5-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc5-rep-elem abnf::cst) (cst-statement-expression-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc6-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)))) (let ((__function__ 'cst-statement-expression-conc6-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc6-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc6-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc6-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 6)) (b* ((abnf::cst1 (cst-statement-expression-conc6-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "method-invocation"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc6-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc6-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc6-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc6-rep-elem abnf::cst) (cst-statement-expression-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-expression-conc7-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)))) (let ((__function__ 'cst-statement-expression-conc7-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-expression-conc7-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-expression-conc7-rep-elem (b* ((abnf::cst1 (cst-statement-expression-conc7-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-rep-elem-match (implies (and (cst-matchp abnf::cst "statement-expression") (equal (cst-statement-expression-conc? abnf::cst) 7)) (b* ((abnf::cst1 (cst-statement-expression-conc7-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "class-instance-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-expression-conc7-rep-elem-of-tree-fix-cst (equal (cst-statement-expression-conc7-rep-elem (abnf::tree-fix abnf::cst)) (cst-statement-expression-conc7-rep-elem abnf::cst)))
Theorem:
(defthm cst-statement-expression-conc7-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-statement-expression-conc7-rep-elem abnf::cst) (cst-statement-expression-conc7-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-case-constant-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "case-constant"))) (let ((__function__ 'cst-case-constant-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-case-constant-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-case-constant-conc-rep-elem (b* ((abnf::cst1 (cst-case-constant-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-rep-elem-match (implies (cst-matchp abnf::cst "case-constant") (b* ((abnf::cst1 (cst-case-constant-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-case-constant-conc-rep-elem-of-tree-fix-cst (equal (cst-case-constant-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-case-constant-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-case-constant-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-case-constant-conc-rep-elem abnf::cst) (cst-case-constant-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-statement-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-statement-conc1-rep-elem (b* ((abnf::cst1 (cst-for-statement-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-for-statement-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc1-rep-elem-of-tree-fix-cst (equal (cst-for-statement-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-statement-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-statement-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc1-rep-elem abnf::cst) (cst-for-statement-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-statement-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-statement-conc2-rep-elem (b* ((abnf::cst1 (cst-for-statement-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "for-statement") (equal (cst-for-statement-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-for-statement-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "enhanced-for-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-conc2-rep-elem-of-tree-fix-cst (equal (cst-for-statement-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-statement-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-statement-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-conc2-rep-elem abnf::cst) (cst-for-statement-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-statement-no-short-if-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-statement-no-short-if-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-statement-no-short-if-conc1-rep-elem (b* ((abnf::cst1 (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst) (cst-for-statement-no-short-if-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-statement-no-short-if-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-statement-no-short-if-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-statement-no-short-if-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-statement-no-short-if-conc2-rep-elem (b* ((abnf::cst1 (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "for-statement-no-short-if") (equal (cst-for-statement-no-short-if-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "enhanced-for-statement-no-short-if"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst (equal (cst-for-statement-no-short-if-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst) (cst-for-statement-no-short-if-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)))) (let ((__function__ 'cst-for-init-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-init-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-init-conc1-rep-elem (b* ((abnf::cst1 (cst-for-init-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-for-init-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc1-rep-elem-of-tree-fix-cst (equal (cst-for-init-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-init-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-init-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc1-rep-elem abnf::cst) (cst-for-init-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-init-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)))) (let ((__function__ 'cst-for-init-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-init-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-init-conc2-rep-elem (b* ((abnf::cst1 (cst-for-init-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "for-init") (equal (cst-for-init-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-for-init-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "local-variable-declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-init-conc2-rep-elem-of-tree-fix-cst (equal (cst-for-init-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-init-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-init-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-init-conc2-rep-elem abnf::cst) (cst-for-init-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-for-update-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "for-update"))) (let ((__function__ 'cst-for-update-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-for-update-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-for-update-conc-rep-elem (b* ((abnf::cst1 (cst-for-update-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-rep-elem-match (implies (cst-matchp abnf::cst "for-update") (b* ((abnf::cst1 (cst-for-update-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement-expression-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-for-update-conc-rep-elem-of-tree-fix-cst (equal (cst-for-update-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-for-update-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-for-update-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-for-update-conc-rep-elem abnf::cst) (cst-for-update-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)))) (let ((__function__ 'cst-variable-access-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-variable-access-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-variable-access-conc1-rep-elem (b* ((abnf::cst1 (cst-variable-access-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-variable-access-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc1-rep-elem-of-tree-fix-cst (equal (cst-variable-access-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-variable-access-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-variable-access-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc1-rep-elem abnf::cst) (cst-variable-access-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-variable-access-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)))) (let ((__function__ 'cst-variable-access-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-variable-access-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-variable-access-conc2-rep-elem (b* ((abnf::cst1 (cst-variable-access-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "variable-access") (equal (cst-variable-access-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-variable-access-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-variable-access-conc2-rep-elem-of-tree-fix-cst (equal (cst-variable-access-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-variable-access-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-variable-access-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-variable-access-conc2-rep-elem abnf::cst) (cst-variable-access-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-expression-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-expression-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-expression-conc1-rep-elem (b* ((abnf::cst1 (cst-expression-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-expression-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "lambda-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc1-rep-elem-of-tree-fix-cst (equal (cst-expression-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-expression-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-expression-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc1-rep-elem abnf::cst) (cst-expression-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-expression-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-expression-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-expression-conc2-rep-elem (b* ((abnf::cst1 (cst-expression-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "expression") (equal (cst-expression-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-expression-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "assignment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc2-rep-elem-of-tree-fix-cst (equal (cst-expression-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-expression-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-expression-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc2-rep-elem abnf::cst) (cst-expression-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)))) (let ((__function__ 'cst-primary-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-primary-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-primary-conc1-rep-elem (b* ((abnf::cst1 (cst-primary-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-primary-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "primary-no-new-array"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc1-rep-elem-of-tree-fix-cst (equal (cst-primary-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-primary-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-primary-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc1-rep-elem abnf::cst) (cst-primary-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-primary-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)))) (let ((__function__ 'cst-primary-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-primary-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-primary-conc2-rep-elem (b* ((abnf::cst1 (cst-primary-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "primary") (equal (cst-primary-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-primary-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "array-creation-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-primary-conc2-rep-elem-of-tree-fix-cst (equal (cst-primary-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-primary-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-primary-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-primary-conc2-rep-elem abnf::cst) (cst-primary-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-postfix-expression-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-postfix-expression-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-postfix-expression-conc1-rep-elem (b* ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "primary"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc1-rep-elem-of-tree-fix-cst (equal (cst-postfix-expression-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc1-rep-elem abnf::cst) (cst-postfix-expression-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-postfix-expression-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-postfix-expression-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-postfix-expression-conc2-rep-elem (b* ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc2-rep-elem-of-tree-fix-cst (equal (cst-postfix-expression-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc2-rep-elem abnf::cst) (cst-postfix-expression-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)))) (let ((__function__ 'cst-postfix-expression-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-postfix-expression-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-postfix-expression-conc3-rep-elem (b* ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "post-increment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc3-rep-elem-of-tree-fix-cst (equal (cst-postfix-expression-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc3-rep-elem abnf::cst) (cst-postfix-expression-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-postfix-expression-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)))) (let ((__function__ 'cst-postfix-expression-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-postfix-expression-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-postfix-expression-conc4-rep-elem (b* ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "postfix-expression") (equal (cst-postfix-expression-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "post-decrement-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-postfix-expression-conc4-rep-elem-of-tree-fix-cst (equal (cst-postfix-expression-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-postfix-expression-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-postfix-expression-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-postfix-expression-conc4-rep-elem abnf::cst) (cst-postfix-expression-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)))) (let ((__function__ 'cst-assignment-expression-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-assignment-expression-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-assignment-expression-conc1-rep-elem (b* ((abnf::cst1 (cst-assignment-expression-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-assignment-expression-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "conditional-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc1-rep-elem-of-tree-fix-cst (equal (cst-assignment-expression-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc1-rep-elem abnf::cst) (cst-assignment-expression-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-assignment-expression-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)))) (let ((__function__ 'cst-assignment-expression-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-assignment-expression-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-assignment-expression-conc2-rep-elem (b* ((abnf::cst1 (cst-assignment-expression-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "assignment-expression") (equal (cst-assignment-expression-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-assignment-expression-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "assignment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-assignment-expression-conc2-rep-elem-of-tree-fix-cst (equal (cst-assignment-expression-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-assignment-expression-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-assignment-expression-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-assignment-expression-conc2-rep-elem abnf::cst) (cst-assignment-expression-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)))) (let ((__function__ 'cst-left-hand-side-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-left-hand-side-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-left-hand-side-conc1-rep-elem (b* ((abnf::cst1 (cst-left-hand-side-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-left-hand-side-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc1-rep-elem-of-tree-fix-cst (equal (cst-left-hand-side-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc1-rep-elem abnf::cst) (cst-left-hand-side-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)))) (let ((__function__ 'cst-left-hand-side-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-left-hand-side-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-left-hand-side-conc2-rep-elem (b* ((abnf::cst1 (cst-left-hand-side-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-left-hand-side-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "field-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc2-rep-elem-of-tree-fix-cst (equal (cst-left-hand-side-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc2-rep-elem abnf::cst) (cst-left-hand-side-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-left-hand-side-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)))) (let ((__function__ 'cst-left-hand-side-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-left-hand-side-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-left-hand-side-conc3-rep-elem (b* ((abnf::cst1 (cst-left-hand-side-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "left-hand-side") (equal (cst-left-hand-side-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-left-hand-side-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "array-access"))) :rule-classes :rewrite)
Theorem:
(defthm cst-left-hand-side-conc3-rep-elem-of-tree-fix-cst (equal (cst-left-hand-side-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-left-hand-side-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-left-hand-side-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-left-hand-side-conc3-rep-elem abnf::cst) (cst-left-hand-side-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)))) (let ((__function__ 'cst-lambda-body-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-lambda-body-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-lambda-body-conc1-rep-elem (b* ((abnf::cst1 (cst-lambda-body-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-lambda-body-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc1-rep-elem-of-tree-fix-cst (equal (cst-lambda-body-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc1-rep-elem abnf::cst) (cst-lambda-body-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lambda-body-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)))) (let ((__function__ 'cst-lambda-body-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-lambda-body-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-lambda-body-conc2-rep-elem (b* ((abnf::cst1 (cst-lambda-body-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "lambda-body") (equal (cst-lambda-body-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-lambda-body-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "block"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lambda-body-conc2-rep-elem-of-tree-fix-cst (equal (cst-lambda-body-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-lambda-body-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-lambda-body-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lambda-body-conc2-rep-elem abnf::cst) (cst-lambda-body-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-expression-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-constant-expression-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-constant-expression-conc-rep-elem (b* ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-elem-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-elem-of-tree-fix-cst (equal (cst-constant-expression-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-constant-expression-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-constant-expression-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-expression-conc-rep-elem abnf::cst) (cst-constant-expression-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x0-ffff-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x0-FFFF"))) (let ((__function__ 'cst-%x0-ffff-nat)) (declare (ignorable __function__)) (acl2::lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x0-ffff-nat (b* ((nat (cst-%x0-ffff-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x0-ffff-nat-of-tree-fix-cst (equal (cst-%x0-ffff-nat (abnf::tree-fix abnf::cst)) (cst-%x0-ffff-nat abnf::cst)))
Theorem:
(defthm cst-%x0-ffff-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x0-ffff-nat abnf::cst) (cst-%x0-ffff-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-%x0-ffff-nat-bounds (implies (cst-matchp abnf::cst "%x0-FFFF") (and (<= 0 (cst-%x0-ffff-nat abnf::cst)) (<= (cst-%x0-ffff-nat abnf::cst) 65535))) :rule-classes :linear)