|
|
|---|
|
|
|
|---|
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)))) (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)))) (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)))) (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)))) (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)))) (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)
Function:
(defun cst-%x0-9-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x0-9"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%x0-9-nat (b* ((nat (cst-%x0-9-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x0-9-nat-of-tree-fix-cst (equal (cst-%x0-9-nat (abnf::tree-fix abnf::cst)) (cst-%x0-9-nat abnf::cst)))
Theorem:
(defthm cst-%x0-9-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x0-9-nat abnf::cst) (cst-%x0-9-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x0-7f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x0-7F"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%x0-7f-nat (b* ((nat (cst-%x0-7f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x0-7f-nat-of-tree-fix-cst (equal (cst-%x0-7f-nat (abnf::tree-fix abnf::cst)) (cst-%x0-7f-nat abnf::cst)))
Theorem:
(defthm cst-%x0-7f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x0-7f-nat abnf::cst) (cst-%x0-7f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%xb-c-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%xB-C"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%xb-c-nat (b* ((nat (cst-%xb-c-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%xb-c-nat-of-tree-fix-cst (equal (cst-%xb-c-nat (abnf::tree-fix abnf::cst)) (cst-%xb-c-nat abnf::cst)))
Theorem:
(defthm cst-%xb-c-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%xb-c-nat abnf::cst) (cst-%xb-c-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%xe-29-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%xE-29"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%xe-29-nat (b* ((nat (cst-%xe-29-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%xe-29-nat-of-tree-fix-cst (equal (cst-%xe-29-nat (abnf::tree-fix abnf::cst)) (cst-%xe-29-nat abnf::cst)))
Theorem:
(defthm cst-%xe-29-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%xe-29-nat abnf::cst) (cst-%xe-29-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%xe-7f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%xE-7F"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%xe-7f-nat (b* ((nat (cst-%xe-7f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%xe-7f-nat-of-tree-fix-cst (equal (cst-%xe-7f-nat (abnf::tree-fix abnf::cst)) (cst-%xe-7f-nat abnf::cst)))
Theorem:
(defthm cst-%xe-7f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%xe-7f-nat abnf::cst) (cst-%xe-7f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x2b-2e-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x2B-2E"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%x2b-2e-nat (b* ((nat (cst-%x2b-2e-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x2b-2e-nat-of-tree-fix-cst (equal (cst-%x2b-2e-nat (abnf::tree-fix abnf::cst)) (cst-%x2b-2e-nat abnf::cst)))
Theorem:
(defthm cst-%x2b-2e-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x2b-2e-nat abnf::cst) (cst-%x2b-2e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x2b-7f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x2B-7F"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%x2b-7f-nat (b* ((nat (cst-%x2b-7f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x2b-7f-nat-of-tree-fix-cst (equal (cst-%x2b-7f-nat (abnf::tree-fix abnf::cst)) (cst-%x2b-7f-nat abnf::cst)))
Theorem:
(defthm cst-%x2b-7f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x2b-7f-nat abnf::cst) (cst-%x2b-7f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x30-7f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x30-7F"))) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst))))
Theorem:
(defthm natp-of-cst-%x30-7f-nat (b* ((nat (cst-%x30-7f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x30-7f-nat-of-tree-fix-cst (equal (cst-%x30-7f-nat (abnf::tree-fix abnf::cst)) (cst-%x30-7f-nat abnf::cst)))
Theorem:
(defthm cst-%x30-7f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x30-7f-nat abnf::cst) (cst-%x30-7f-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-%x0-9-nat-bounds (implies (cst-matchp abnf::cst "%x0-9") (and (<= 0 (cst-%x0-9-nat abnf::cst)) (<= (cst-%x0-9-nat abnf::cst) 9))) :rule-classes :linear)
Theorem:
(defthm cst-%x0-7f-nat-bounds (implies (cst-matchp abnf::cst "%x0-7F") (and (<= 0 (cst-%x0-7f-nat abnf::cst)) (<= (cst-%x0-7f-nat abnf::cst) 127))) :rule-classes :linear)
Theorem:
(defthm cst-%xb-c-nat-bounds (implies (cst-matchp abnf::cst "%xB-C") (and (<= 11 (cst-%xb-c-nat abnf::cst)) (<= (cst-%xb-c-nat abnf::cst) 12))) :rule-classes :linear)
Theorem:
(defthm cst-%xe-29-nat-bounds (implies (cst-matchp abnf::cst "%xE-29") (and (<= 14 (cst-%xe-29-nat abnf::cst)) (<= (cst-%xe-29-nat abnf::cst) 41))) :rule-classes :linear)
Theorem:
(defthm cst-%xe-7f-nat-bounds (implies (cst-matchp abnf::cst "%xE-7F") (and (<= 14 (cst-%xe-7f-nat abnf::cst)) (<= (cst-%xe-7f-nat abnf::cst) 127))) :rule-classes :linear)
Theorem:
(defthm cst-%x2b-2e-nat-bounds (implies (cst-matchp abnf::cst "%x2B-2E") (and (<= 43 (cst-%x2b-2e-nat abnf::cst)) (<= (cst-%x2b-2e-nat abnf::cst) 46))) :rule-classes :linear)
Theorem:
(defthm cst-%x2b-7f-nat-bounds (implies (cst-matchp abnf::cst "%x2B-7F") (and (<= 43 (cst-%x2b-7f-nat abnf::cst)) (<= (cst-%x2b-7f-nat abnf::cst) 127))) :rule-classes :linear)
Theorem:
(defthm cst-%x30-7f-nat-bounds (implies (cst-matchp abnf::cst "%x30-7F") (and (<= 48 (cst-%x30-7f-nat abnf::cst)) (<= (cst-%x30-7f-nat abnf::cst) 127))) :rule-classes :linear)
Theorem:
(defthm |CST-"!"-LEAFTERM| (implies (cst-matchp abnf::cst "\"!\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"!="-LEAFTERM| (implies (cst-matchp abnf::cst "\"!=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"#"-LEAFTERM| (implies (cst-matchp abnf::cst "\"#\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"##"-LEAFTERM| (implies (cst-matchp abnf::cst "\"##\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"%"-LEAFTERM| (implies (cst-matchp abnf::cst "\"%\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"%:"-LEAFTERM| (implies (cst-matchp abnf::cst "\"%:\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"%:%:"-LEAFTERM| (implies (cst-matchp abnf::cst "\"%:%:\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"%="-LEAFTERM| (implies (cst-matchp abnf::cst "\"%=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"%>"-LEAFTERM| (implies (cst-matchp abnf::cst "\"%>\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"&"-LEAFTERM| (implies (cst-matchp abnf::cst "\"&\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"&&"-LEAFTERM| (implies (cst-matchp abnf::cst "\"&&\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"&="-LEAFTERM| (implies (cst-matchp abnf::cst "\"&=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"("-LEAFTERM| (implies (cst-matchp abnf::cst "\"(\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-")"-LEAFTERM| (implies (cst-matchp abnf::cst "\")\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"*"-LEAFTERM| (implies (cst-matchp abnf::cst "\"*\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"*="-LEAFTERM| (implies (cst-matchp abnf::cst "\"*=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"+"-LEAFTERM| (implies (cst-matchp abnf::cst "\"+\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"++"-LEAFTERM| (implies (cst-matchp abnf::cst "\"++\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"+="-LEAFTERM| (implies (cst-matchp abnf::cst "\"+=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-","-LEAFTERM| (implies (cst-matchp abnf::cst "\",\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"-"-LEAFTERM| (implies (cst-matchp abnf::cst "\"-\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"--"-LEAFTERM| (implies (cst-matchp abnf::cst "\"--\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"-="-LEAFTERM| (implies (cst-matchp abnf::cst "\"-=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"->"-LEAFTERM| (implies (cst-matchp abnf::cst "\"->\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"."-LEAFTERM| (implies (cst-matchp abnf::cst "\".\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"..."-LEAFTERM| (implies (cst-matchp abnf::cst "\"...\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"/"-LEAFTERM| (implies (cst-matchp abnf::cst "\"/\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"/*"-LEAFTERM| (implies (cst-matchp abnf::cst "\"/*\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"//"-LEAFTERM| (implies (cst-matchp abnf::cst "\"//\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"/="-LEAFTERM| (implies (cst-matchp abnf::cst "\"/=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"0"-LEAFTERM| (implies (cst-matchp abnf::cst "\"0\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"1"-LEAFTERM| (implies (cst-matchp abnf::cst "\"1\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"2"-LEAFTERM| (implies (cst-matchp abnf::cst "\"2\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"3"-LEAFTERM| (implies (cst-matchp abnf::cst "\"3\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"4"-LEAFTERM| (implies (cst-matchp abnf::cst "\"4\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"5"-LEAFTERM| (implies (cst-matchp abnf::cst "\"5\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"6"-LEAFTERM| (implies (cst-matchp abnf::cst "\"6\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"7"-LEAFTERM| (implies (cst-matchp abnf::cst "\"7\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"8"-LEAFTERM| (implies (cst-matchp abnf::cst "\"8\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"9"-LEAFTERM| (implies (cst-matchp abnf::cst "\"9\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-":"-LEAFTERM| (implies (cst-matchp abnf::cst "\":\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-":>"-LEAFTERM| (implies (cst-matchp abnf::cst "\":>\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-";"-LEAFTERM| (implies (cst-matchp abnf::cst "\";\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<"-LEAFTERM| (implies (cst-matchp abnf::cst "\"<\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<%"-LEAFTERM| (implies (cst-matchp abnf::cst "\"<%\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<:"-LEAFTERM| (implies (cst-matchp abnf::cst "\"<:\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<<"-LEAFTERM| (implies (cst-matchp abnf::cst "\"<<\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<<="-LEAFTERM| (implies (cst-matchp abnf::cst "\"<<=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"<="-LEAFTERM| (implies (cst-matchp abnf::cst "\"<=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"="-LEAFTERM| (implies (cst-matchp abnf::cst "\"=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"=="-LEAFTERM| (implies (cst-matchp abnf::cst "\"==\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-">"-LEAFTERM| (implies (cst-matchp abnf::cst "\">\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-">="-LEAFTERM| (implies (cst-matchp abnf::cst "\">=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-">>"-LEAFTERM| (implies (cst-matchp abnf::cst "\">>\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-">>="-LEAFTERM| (implies (cst-matchp abnf::cst "\">>=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"?"-LEAFTERM| (implies (cst-matchp abnf::cst "\"?\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"["-LEAFTERM| (implies (cst-matchp abnf::cst "\"[\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"]"-LEAFTERM| (implies (cst-matchp abnf::cst "\"]\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"^"-LEAFTERM| (implies (cst-matchp abnf::cst "\"^\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"^="-LEAFTERM| (implies (cst-matchp abnf::cst "\"^=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"_"-LEAFTERM| (implies (cst-matchp abnf::cst "\"_\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"{"-LEAFTERM| (implies (cst-matchp abnf::cst "\"{\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"\|"-LEAFTERM| (implies (cst-matchp abnf::cst "\"|\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"\|="-LEAFTERM| (implies (cst-matchp abnf::cst "\"|=\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"\|\|"-LEAFTERM| (implies (cst-matchp abnf::cst "\"||\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"}"-LEAFTERM| (implies (cst-matchp abnf::cst "\"}\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-"~"-LEAFTERM| (implies (cst-matchp abnf::cst "\"~\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"0x"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"0x\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"a"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"a\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"b"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"b\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"c"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"c\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"d"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"d\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"e"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"e\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"f"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"f\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"g"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"g\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"h"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"h\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"i"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"i\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"j"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"j\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"k"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"k\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"l"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"l\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"m"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"m\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"n"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"n\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"o"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"o\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"p"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"p\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"q"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"q\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"r"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"r\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"s"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"s\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"t"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"t\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"u"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"u\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"v"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"v\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"w"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"w\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"x"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"x\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"y"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"y\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%i"z"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"z\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"LL"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"LL\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Alignas"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Alignas\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Alignof"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Alignof\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Atomic"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Atomic\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Bool"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Bool\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Complex"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Complex\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Generic"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Generic\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Imaginary"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Imaginary\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Noreturn"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Noreturn\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Static_assert"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Static_assert\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"_Thread_local"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"_Thread_local\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"auto"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"auto\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"break"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"break\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"case"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"case\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"char"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"char\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"const"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"const\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"continue"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"continue\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"default"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"default\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"do"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"do\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"double"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"double\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"else"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"else\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"enum"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"enum\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"extern"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"extern\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"float"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"float\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"for"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"for\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"goto"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"goto\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"if"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"if\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"inline"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"inline\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"int"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"int\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"ll"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"ll\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"long"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"long\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"register"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"register\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"restrict"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"restrict\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"return"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"return\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"short"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"short\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"signed"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"signed\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"sizeof"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"sizeof\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"static"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"static\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"struct"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"struct\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"switch"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"switch\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"typedef"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"typedef\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"union"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"union\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"unsigned"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"unsigned\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"void"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"void\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"volatile"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"volatile\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"while"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"while\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm cst-horizontal-tab-nonleaf (implies (cst-matchp abnf::cst "horizontal-tab") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-line-feed-nonleaf (implies (cst-matchp abnf::cst "line-feed") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-vertical-tab-nonleaf (implies (cst-matchp abnf::cst "vertical-tab") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-form-feed-nonleaf (implies (cst-matchp abnf::cst "form-feed") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-carriage-return-nonleaf (implies (cst-matchp abnf::cst "carriage-return") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-space-nonleaf (implies (cst-matchp abnf::cst "space") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-double-quote-nonleaf (implies (cst-matchp abnf::cst "double-quote") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-nonleaf (implies (cst-matchp abnf::cst "not-line-feed-or-carriage-return") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-nonleaf (implies (cst-matchp abnf::cst "not-star-or-line-feed-or-carriage-return") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-nonleaf (implies (cst-matchp abnf::cst "not-star-or-slash-or-line-feed-or-carriage-return") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-nonleaf (implies (cst-matchp abnf::cst "character") (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-keyword-nonleaf (implies (cst-matchp abnf::cst "keyword") (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-nondigit-nonleaf (implies (cst-matchp abnf::cst "identifier-nondigit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-nondigit-nonleaf (implies (cst-matchp abnf::cst "nondigit") (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-constant-nonleaf (implies (cst-matchp abnf::cst "constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-integer-constant-nonleaf (implies (cst-matchp abnf::cst "integer-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-decimal-constant-nonleaf (implies (cst-matchp abnf::cst "decimal-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-constant-nonleaf (implies (cst-matchp abnf::cst "octal-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-constant-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-prefix-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-prefix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-nonzero-digit-nonleaf (implies (cst-matchp abnf::cst "nonzero-digit") (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-hexadecimal-digit-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-digit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-integer-suffix-nonleaf (implies (cst-matchp abnf::cst "integer-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-unsigned-suffix-nonleaf (implies (cst-matchp abnf::cst "unsigned-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-long-suffix-nonleaf (implies (cst-matchp abnf::cst "long-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-long-long-suffix-nonleaf (implies (cst-matchp abnf::cst "long-long-suffix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enumeration-constant-nonleaf (implies (cst-matchp abnf::cst "enumeration-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-punctuator-nonleaf (implies (cst-matchp abnf::cst "punctuator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-new-line-nonleaf (implies (cst-matchp abnf::cst "new-line") (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-block-comment-nonleaf (implies (cst-matchp abnf::cst "block-comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-rest-of-block-comment-nonleaf (implies (cst-matchp abnf::cst "rest-of-block-comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-rest-of-block-comment-after-star-nonleaf (implies (cst-matchp abnf::cst "rest-of-block-comment-after-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-line-comment-nonleaf (implies (cst-matchp abnf::cst "line-comment") (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-lexeme-nonleaf (implies (cst-matchp abnf::cst "lexeme") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-primary-expression-nonleaf (implies (cst-matchp abnf::cst "primary-expression") (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-argument-expression-list-nonleaf (implies (cst-matchp abnf::cst "argument-expression-list") (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-unary-operator-nonleaf (implies (cst-matchp abnf::cst "unary-operator") (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-logical-and-expression-nonleaf (implies (cst-matchp abnf::cst "logical-and-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-logical-or-expression-nonleaf (implies (cst-matchp abnf::cst "logical-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-operator-nonleaf (implies (cst-matchp abnf::cst "assignment-operator") (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-constant-expression-nonleaf (implies (cst-matchp abnf::cst "constant-expression") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-declaration-nonleaf (implies (cst-matchp abnf::cst "declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-declaration-specifiers-nonleaf (implies (cst-matchp abnf::cst "declaration-specifiers") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-init-declarator-list-nonleaf (implies (cst-matchp abnf::cst "init-declarator-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-init-declarator-nonleaf (implies (cst-matchp abnf::cst "init-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-storage-class-specifier-nonleaf (implies (cst-matchp abnf::cst "storage-class-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-specifier-nonleaf (implies (cst-matchp abnf::cst "type-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-or-union-specifier-nonleaf (implies (cst-matchp abnf::cst "struct-or-union-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-or-union-nonleaf (implies (cst-matchp abnf::cst "struct-or-union") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-declaration-list-nonleaf (implies (cst-matchp abnf::cst "struct-declaration-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-declaration-nonleaf (implies (cst-matchp abnf::cst "struct-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-specifier-qualifier-list-nonleaf (implies (cst-matchp abnf::cst "specifier-qualifier-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-declarator-list-nonleaf (implies (cst-matchp abnf::cst "struct-declarator-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-struct-declarator-nonleaf (implies (cst-matchp abnf::cst "struct-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enum-specifier-nonleaf (implies (cst-matchp abnf::cst "enum-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-declarator-nonleaf (implies (cst-matchp abnf::cst "declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-direct-declarator-nonleaf (implies (cst-matchp abnf::cst "direct-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-pointer-nonleaf (implies (cst-matchp abnf::cst "pointer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-parameter-type-list-nonleaf (implies (cst-matchp abnf::cst "parameter-type-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-parameter-list-nonleaf (implies (cst-matchp abnf::cst "parameter-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-parameter-declaration-nonleaf (implies (cst-matchp abnf::cst "parameter-declaration") (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-abstract-declarator-nonleaf (implies (cst-matchp abnf::cst "abstract-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-direct-abstract-declarator-nonleaf (implies (cst-matchp abnf::cst "direct-abstract-declarator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-typedef-name-nonleaf (implies (cst-matchp abnf::cst "typedef-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-initializer-nonleaf (implies (cst-matchp abnf::cst "initializer") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-initializer-list-nonleaf (implies (cst-matchp abnf::cst "initializer-list") (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-labeled-statement-nonleaf (implies (cst-matchp abnf::cst "labeled-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-compound-statement-nonleaf (implies (cst-matchp abnf::cst "compound-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-block-item-list-nonleaf (implies (cst-matchp abnf::cst "block-item-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-block-item-nonleaf (implies (cst-matchp abnf::cst "block-item") (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-selection-statement-nonleaf (implies (cst-matchp abnf::cst "selection-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-iteration-statement-nonleaf (implies (cst-matchp abnf::cst "iteration-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-jump-statement-nonleaf (implies (cst-matchp abnf::cst "jump-statement") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-translation-unit-nonleaf (implies (cst-matchp abnf::cst "translation-unit") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-external-declaration-nonleaf (implies (cst-matchp abnf::cst "external-declaration") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-function-definition-nonleaf (implies (cst-matchp abnf::cst "function-definition") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-declaration-list-nonleaf (implies (cst-matchp abnf::cst "declaration-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-horizontal-tab-rulename (implies (cst-matchp abnf::cst "horizontal-tab") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "horizontal-tab"))))
Theorem:
(defthm cst-line-feed-rulename (implies (cst-matchp abnf::cst "line-feed") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "line-feed"))))
Theorem:
(defthm cst-vertical-tab-rulename (implies (cst-matchp abnf::cst "vertical-tab") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "vertical-tab"))))
Theorem:
(defthm cst-form-feed-rulename (implies (cst-matchp abnf::cst "form-feed") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "form-feed"))))
Theorem:
(defthm cst-carriage-return-rulename (implies (cst-matchp abnf::cst "carriage-return") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "carriage-return"))))
Theorem:
(defthm cst-space-rulename (implies (cst-matchp abnf::cst "space") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "space"))))
Theorem:
(defthm cst-double-quote-rulename (implies (cst-matchp abnf::cst "double-quote") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "double-quote"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-rulename (implies (cst-matchp abnf::cst "not-line-feed-or-carriage-return") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "not-line-feed-or-carriage-return"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-rulename (implies (cst-matchp abnf::cst "not-star-or-line-feed-or-carriage-return") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "not-star-or-line-feed-or-carriage-return"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-rulename (implies (cst-matchp abnf::cst "not-star-or-slash-or-line-feed-or-carriage-return") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "not-star-or-slash-or-line-feed-or-carriage-return"))))
Theorem:
(defthm cst-character-rulename (implies (cst-matchp abnf::cst "character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character"))))
Theorem:
(defthm cst-token-rulename (implies (cst-matchp abnf::cst "token") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "token"))))
Theorem:
(defthm cst-keyword-rulename (implies (cst-matchp abnf::cst "keyword") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "keyword"))))
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-nondigit-rulename (implies (cst-matchp abnf::cst "identifier-nondigit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "identifier-nondigit"))))
Theorem:
(defthm cst-nondigit-rulename (implies (cst-matchp abnf::cst "nondigit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "nondigit"))))
Theorem:
(defthm cst-digit-rulename (implies (cst-matchp abnf::cst "digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digit"))))
Theorem:
(defthm cst-constant-rulename (implies (cst-matchp abnf::cst "constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "constant"))))
Theorem:
(defthm cst-integer-constant-rulename (implies (cst-matchp abnf::cst "integer-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "integer-constant"))))
Theorem:
(defthm cst-decimal-constant-rulename (implies (cst-matchp abnf::cst "decimal-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "decimal-constant"))))
Theorem:
(defthm cst-octal-constant-rulename (implies (cst-matchp abnf::cst "octal-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-constant"))))
Theorem:
(defthm cst-hexadecimal-constant-rulename (implies (cst-matchp abnf::cst "hexadecimal-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-constant"))))
Theorem:
(defthm cst-hexadecimal-prefix-rulename (implies (cst-matchp abnf::cst "hexadecimal-prefix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-prefix"))))
Theorem:
(defthm cst-nonzero-digit-rulename (implies (cst-matchp abnf::cst "nonzero-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "nonzero-digit"))))
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-hexadecimal-digit-rulename (implies (cst-matchp abnf::cst "hexadecimal-digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-digit"))))
Theorem:
(defthm cst-integer-suffix-rulename (implies (cst-matchp abnf::cst "integer-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "integer-suffix"))))
Theorem:
(defthm cst-unsigned-suffix-rulename (implies (cst-matchp abnf::cst "unsigned-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unsigned-suffix"))))
Theorem:
(defthm cst-long-suffix-rulename (implies (cst-matchp abnf::cst "long-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "long-suffix"))))
Theorem:
(defthm cst-long-long-suffix-rulename (implies (cst-matchp abnf::cst "long-long-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "long-long-suffix"))))
Theorem:
(defthm cst-enumeration-constant-rulename (implies (cst-matchp abnf::cst "enumeration-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enumeration-constant"))))
Theorem:
(defthm cst-punctuator-rulename (implies (cst-matchp abnf::cst "punctuator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "punctuator"))))
Theorem:
(defthm cst-new-line-rulename (implies (cst-matchp abnf::cst "new-line") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "new-line"))))
Theorem:
(defthm cst-comment-rulename (implies (cst-matchp abnf::cst "comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "comment"))))
Theorem:
(defthm cst-block-comment-rulename (implies (cst-matchp abnf::cst "block-comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-rulename (implies (cst-matchp abnf::cst "rest-of-block-comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "rest-of-block-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-after-star-rulename (implies (cst-matchp abnf::cst "rest-of-block-comment-after-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "rest-of-block-comment-after-star"))))
Theorem:
(defthm cst-line-comment-rulename (implies (cst-matchp abnf::cst "line-comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "line-comment"))))
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-lexeme-rulename (implies (cst-matchp abnf::cst "lexeme") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lexeme"))))
Theorem:
(defthm cst-primary-expression-rulename (implies (cst-matchp abnf::cst "primary-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "primary-expression"))))
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-argument-expression-list-rulename (implies (cst-matchp abnf::cst "argument-expression-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "argument-expression-list"))))
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-unary-operator-rulename (implies (cst-matchp abnf::cst "unary-operator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "unary-operator"))))
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-logical-and-expression-rulename (implies (cst-matchp abnf::cst "logical-and-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "logical-and-expression"))))
Theorem:
(defthm cst-logical-or-expression-rulename (implies (cst-matchp abnf::cst "logical-or-expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "logical-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-operator-rulename (implies (cst-matchp abnf::cst "assignment-operator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "assignment-operator"))))
Theorem:
(defthm cst-expression-rulename (implies (cst-matchp abnf::cst "expression") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "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-declaration-rulename (implies (cst-matchp abnf::cst "declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "declaration"))))
Theorem:
(defthm cst-declaration-specifiers-rulename (implies (cst-matchp abnf::cst "declaration-specifiers") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "declaration-specifiers"))))
Theorem:
(defthm cst-init-declarator-list-rulename (implies (cst-matchp abnf::cst "init-declarator-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "init-declarator-list"))))
Theorem:
(defthm cst-init-declarator-rulename (implies (cst-matchp abnf::cst "init-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "init-declarator"))))
Theorem:
(defthm cst-storage-class-specifier-rulename (implies (cst-matchp abnf::cst "storage-class-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "storage-class-specifier"))))
Theorem:
(defthm cst-type-specifier-rulename (implies (cst-matchp abnf::cst "type-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-specifier"))))
Theorem:
(defthm cst-struct-or-union-specifier-rulename (implies (cst-matchp abnf::cst "struct-or-union-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-or-union-specifier"))))
Theorem:
(defthm cst-struct-or-union-rulename (implies (cst-matchp abnf::cst "struct-or-union") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-or-union"))))
Theorem:
(defthm cst-struct-declaration-list-rulename (implies (cst-matchp abnf::cst "struct-declaration-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-declaration-list"))))
Theorem:
(defthm cst-struct-declaration-rulename (implies (cst-matchp abnf::cst "struct-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-declaration"))))
Theorem:
(defthm cst-specifier-qualifier-list-rulename (implies (cst-matchp abnf::cst "specifier-qualifier-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "specifier-qualifier-list"))))
Theorem:
(defthm cst-struct-declarator-list-rulename (implies (cst-matchp abnf::cst "struct-declarator-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-declarator-list"))))
Theorem:
(defthm cst-struct-declarator-rulename (implies (cst-matchp abnf::cst "struct-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "struct-declarator"))))
Theorem:
(defthm cst-enum-specifier-rulename (implies (cst-matchp abnf::cst "enum-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enum-specifier"))))
Theorem:
(defthm cst-declarator-rulename (implies (cst-matchp abnf::cst "declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "declarator"))))
Theorem:
(defthm cst-direct-declarator-rulename (implies (cst-matchp abnf::cst "direct-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "direct-declarator"))))
Theorem:
(defthm cst-pointer-rulename (implies (cst-matchp abnf::cst "pointer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "pointer"))))
Theorem:
(defthm cst-parameter-type-list-rulename (implies (cst-matchp abnf::cst "parameter-type-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "parameter-type-list"))))
Theorem:
(defthm cst-parameter-list-rulename (implies (cst-matchp abnf::cst "parameter-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "parameter-list"))))
Theorem:
(defthm cst-parameter-declaration-rulename (implies (cst-matchp abnf::cst "parameter-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "parameter-declaration"))))
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-abstract-declarator-rulename (implies (cst-matchp abnf::cst "abstract-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "abstract-declarator"))))
Theorem:
(defthm cst-direct-abstract-declarator-rulename (implies (cst-matchp abnf::cst "direct-abstract-declarator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "direct-abstract-declarator"))))
Theorem:
(defthm cst-typedef-name-rulename (implies (cst-matchp abnf::cst "typedef-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "typedef-name"))))
Theorem:
(defthm cst-initializer-rulename (implies (cst-matchp abnf::cst "initializer") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "initializer"))))
Theorem:
(defthm cst-initializer-list-rulename (implies (cst-matchp abnf::cst "initializer-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "initializer-list"))))
Theorem:
(defthm cst-statement-rulename (implies (cst-matchp abnf::cst "statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "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-compound-statement-rulename (implies (cst-matchp abnf::cst "compound-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "compound-statement"))))
Theorem:
(defthm cst-block-item-list-rulename (implies (cst-matchp abnf::cst "block-item-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block-item-list"))))
Theorem:
(defthm cst-block-item-rulename (implies (cst-matchp abnf::cst "block-item") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "block-item"))))
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-selection-statement-rulename (implies (cst-matchp abnf::cst "selection-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "selection-statement"))))
Theorem:
(defthm cst-iteration-statement-rulename (implies (cst-matchp abnf::cst "iteration-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "iteration-statement"))))
Theorem:
(defthm cst-jump-statement-rulename (implies (cst-matchp abnf::cst "jump-statement") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "jump-statement"))))
Theorem:
(defthm cst-translation-unit-rulename (implies (cst-matchp abnf::cst "translation-unit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "translation-unit"))))
Theorem:
(defthm cst-external-declaration-rulename (implies (cst-matchp abnf::cst "external-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "external-declaration"))))
Theorem:
(defthm cst-function-definition-rulename (implies (cst-matchp abnf::cst "function-definition") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "function-definition"))))
Theorem:
(defthm cst-declaration-list-rulename (implies (cst-matchp abnf::cst "declaration-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "declaration-list"))))
Theorem:
(defthm cst-horizontal-tab-branches-match-alt (implies (cst-matchp abnf::cst "horizontal-tab") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x9")))
Theorem:
(defthm cst-line-feed-branches-match-alt (implies (cst-matchp abnf::cst "line-feed") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%xA")))
Theorem:
(defthm cst-vertical-tab-branches-match-alt (implies (cst-matchp abnf::cst "vertical-tab") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%xB")))
Theorem:
(defthm cst-form-feed-branches-match-alt (implies (cst-matchp abnf::cst "form-feed") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%xC")))
Theorem:
(defthm cst-carriage-return-branches-match-alt (implies (cst-matchp abnf::cst "carriage-return") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%xD")))
Theorem:
(defthm cst-space-branches-match-alt (implies (cst-matchp abnf::cst "space") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x20")))
Theorem:
(defthm cst-double-quote-branches-match-alt (implies (cst-matchp abnf::cst "double-quote") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x22")))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-branches-match-alt (implies (cst-matchp abnf::cst "not-line-feed-or-carriage-return") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x0-9 / %xB-C / %xE-7F")))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-branches-match-alt (implies (cst-matchp abnf::cst "not-star-or-line-feed-or-carriage-return") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x0-9 / %xB-C / %xE-29 / %x2B-7F")))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-branches-match-alt (implies (cst-matchp abnf::cst "not-star-or-slash-or-line-feed-or-carriage-return") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x0-9 / %xB-C / %xE-29 / %x2B-2E / %x30-7F")))
Theorem:
(defthm cst-character-branches-match-alt (implies (cst-matchp abnf::cst "character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x0-7F")))
Theorem:
(defthm cst-token-branches-match-alt (implies (cst-matchp abnf::cst "token") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "keyword / identifier / constant / punctuator")))
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\"auto\" / %s\"break\" / %s\"case\" / %s\"char\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extern\" / %s\"float\" / %s\"for\" / %s\"goto\" / %s\"if\" / %s\"inline\" / %s\"int\" / %s\"long\" / %s\"register\" / %s\"restrict\" / %s\"return\" / %s\"short\" / %s\"signed\" / %s\"sizeof\" / %s\"static\" / %s\"struct\" / %s\"switch\" / %s\"typedef\" / %s\"union\" / %s\"unsigned\" / %s\"void\" / %s\"volatile\" / %s\"while\" / %s\"_Alignas\" / %s\"_Alignof\" / %s\"_Atomic\" / %s\"_Bool\" / %s\"_Complex\" / %s\"_Generic\" / %s\"_Imaginary\" / %s\"_Noreturn\" / %s\"_Static_assert\" / %s\"_Thread_local\"")))
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-nondigit / identifier identifier-nondigit / identifier digit")))
Theorem:
(defthm cst-identifier-nondigit-branches-match-alt (implies (cst-matchp abnf::cst "identifier-nondigit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "nondigit")))
Theorem:
(defthm cst-nondigit-branches-match-alt (implies (cst-matchp abnf::cst "nondigit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"_\" / %i\"a\" / %i\"b\" / %i\"c\" / %i\"d\" / %i\"e\" / %i\"f\" / %i\"g\" / %i\"h\" / %i\"i\" / %i\"j\" / %i\"k\" / %i\"l\" / %i\"m\" / %i\"n\" / %i\"o\" / %i\"p\" / %i\"q\" / %i\"r\" / %i\"s\" / %i\"t\" / %i\"u\" / %i\"v\" / %i\"w\" / %i\"x\" / %i\"y\" / %i\"z\"")))
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\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"")))
Theorem:
(defthm cst-constant-branches-match-alt (implies (cst-matchp abnf::cst "constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-constant / enumeration-constant")))
Theorem:
(defthm cst-integer-constant-branches-match-alt (implies (cst-matchp abnf::cst "integer-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-constant [ integer-suffix ] / octal-constant [ integer-suffix ] / hexadecimal-constant [ integer-suffix ]")))
Theorem:
(defthm cst-decimal-constant-branches-match-alt (implies (cst-matchp abnf::cst "decimal-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "nonzero-digit / decimal-constant digit")))
Theorem:
(defthm cst-octal-constant-branches-match-alt (implies (cst-matchp abnf::cst "octal-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / octal-constant octal-digit")))
Theorem:
(defthm cst-hexadecimal-constant-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-prefix hexadecimal-digit / hexadecimal-constant hexadecimal-digit")))
Theorem:
(defthm cst-hexadecimal-prefix-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-prefix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"0x\"")))
Theorem:
(defthm cst-nonzero-digit-branches-match-alt (implies (cst-matchp abnf::cst "nonzero-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"")))
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-hexadecimal-digit-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / %i\"a\" / %i\"b\" / %i\"c\" / %i\"d\" / %i\"e\" / %i\"f\"")))
Theorem:
(defthm cst-integer-suffix-branches-match-alt (implies (cst-matchp abnf::cst "integer-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "unsigned-suffix [ long-suffix ] / unsigned-suffix [ long-long-suffix ] / long-suffix [ unsigned-suffix ] / long-long-suffix [ unsigned-suffix ]")))
Theorem:
(defthm cst-unsigned-suffix-branches-match-alt (implies (cst-matchp abnf::cst "unsigned-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"u\"")))
Theorem:
(defthm cst-long-suffix-branches-match-alt (implies (cst-matchp abnf::cst "long-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"l\"")))
Theorem:
(defthm cst-long-long-suffix-branches-match-alt (implies (cst-matchp abnf::cst "long-long-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"ll\" / %s\"LL\"")))
Theorem:
(defthm cst-enumeration-constant-branches-match-alt (implies (cst-matchp abnf::cst "enumeration-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier")))
Theorem:
(defthm cst-punctuator-branches-match-alt (implies (cst-matchp abnf::cst "punctuator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"[\" / \"]\" / \"(\" / \")\" / \"{\" / \"}\" / \".\" / \"->\" / \"++\" / \"--\" / \"&\" / \"*\" / \"+\" / \"-\" / \"~\" / \"!\" / \"/\" / \"%\" / \"<<\" / \">>\" / \"<\" / \">\" / \"<=\" / \">=\" / \"==\" / \"!=\" / \"^\" / \"|\" / \"&&\" / \"||\" / \"?\" / \":\" / \";\" / \"...\" / \"=\" / \"*=\" / \"/=\" / \"%=\" / \"+=\" / \"-=\" / \"<<=\" / \">>=\" / \"&=\" / \"^=\" / \"|=\" / \",\" / \"#\" / \"##\" / \"<:\" / \":>\" / \"<%\" / \"%>\" / \"%:\" / \"%:%:\"")))
Theorem:
(defthm cst-new-line-branches-match-alt (implies (cst-matchp abnf::cst "new-line") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ carriage-return ] line-feed")))
Theorem:
(defthm cst-comment-branches-match-alt (implies (cst-matchp abnf::cst "comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "block-comment / line-comment")))
Theorem:
(defthm cst-block-comment-branches-match-alt (implies (cst-matchp abnf::cst "block-comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"/*\" rest-of-block-comment")))
Theorem:
(defthm cst-rest-of-block-comment-branches-match-alt (implies (cst-matchp abnf::cst "rest-of-block-comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"*\" rest-of-block-comment-after-star / not-star-or-line-feed-or-carriage-return rest-of-block-comment / new-line rest-of-block-comment")))
Theorem:
(defthm cst-rest-of-block-comment-after-star-branches-match-alt (implies (cst-matchp abnf::cst "rest-of-block-comment-after-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"/\" / \"*\" rest-of-block-comment-after-star / not-star-or-slash-or-line-feed-or-carriage-return rest-of-block-comment / new-line rest-of-block-comment")))
Theorem:
(defthm cst-line-comment-branches-match-alt (implies (cst-matchp abnf::cst "line-comment") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"//\" *not-line-feed-or-carriage-return")))
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) "space / horizontal-tab / vertical-tab / form-feed / new-line")))
Theorem:
(defthm cst-lexeme-branches-match-alt (implies (cst-matchp abnf::cst "lexeme") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "token / comment / white-space")))
Theorem:
(defthm cst-primary-expression-branches-match-alt (implies (cst-matchp abnf::cst "primary-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / constant \"(\" expression \")\"")))
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 / postfix-expression \"[\" expression \"]\" / identifier \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\"")))
Theorem:
(defthm cst-argument-expression-list-branches-match-alt (implies (cst-matchp abnf::cst "argument-expression-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment-expression / argument-expression-list \",\" assignment-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) "postfix-expression / \"++\" unary-expression / \"--\" unary-expression / unary-operator cast-expression")))
Theorem:
(defthm cst-unary-operator-branches-match-alt (implies (cst-matchp abnf::cst "unary-operator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"&\" / \"*\" / \"+\" / \"-\" / \"~\" / \"!\"")))
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) "unary-expression / \"(\" type-name \")\" cast-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) "cast-expression / multiplicative-expression \"*\" cast-expression / multiplicative-expression \"/\" cast-expression / multiplicative-expression \"%\" cast-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")))
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")))
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-logical-and-expression-branches-match-alt (implies (cst-matchp abnf::cst "logical-and-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "inclusive-or-expression / logical-and-expression \"&&\" inclusive-or-expression")))
Theorem:
(defthm cst-logical-or-expression-branches-match-alt (implies (cst-matchp abnf::cst "logical-or-expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "logical-and-expression / logical-or-expression \"||\" logical-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) "logical-or-expression / logical-or-expression \"?\" expression \":\" conditional-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 / unary-expression assignment-operator assignment-expression")))
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-expression-branches-match-alt (implies (cst-matchp abnf::cst "expression") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment-expression")))
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) "conditional-expression")))
Theorem:
(defthm cst-declaration-branches-match-alt (implies (cst-matchp abnf::cst "declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration-specifiers [ init-declarator-list ] \";\"")))
Theorem:
(defthm cst-declaration-specifiers-branches-match-alt (implies (cst-matchp abnf::cst "declaration-specifiers") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "storage-class-specifier [ declaration-specifiers ] / type-specifier [ declaration-specifiers ]")))
Theorem:
(defthm cst-init-declarator-list-branches-match-alt (implies (cst-matchp abnf::cst "init-declarator-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "init-declarator")))
Theorem:
(defthm cst-init-declarator-branches-match-alt (implies (cst-matchp abnf::cst "init-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declarator / declarator \"=\" initializer")))
Theorem:
(defthm cst-storage-class-specifier-branches-match-alt (implies (cst-matchp abnf::cst "storage-class-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"extern\"")))
Theorem:
(defthm cst-type-specifier-branches-match-alt (implies (cst-matchp abnf::cst "type-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"void\" / %s\"char\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"float\" / %s\"double\" / %s\"signed\" / %s\"unsigned\" / %s\"_Bool\" / struct-or-union-specifier / enum-specifier / typedef-name")))
Theorem:
(defthm cst-struct-or-union-specifier-branches-match-alt (implies (cst-matchp abnf::cst "struct-or-union-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "struct-or-union [ identifier ] \"{\" struct-declaration-list \"}\" / struct-or-union identifier")))
Theorem:
(defthm cst-struct-or-union-branches-match-alt (implies (cst-matchp abnf::cst "struct-or-union") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"struct\" / %s\"union\"")))
Theorem:
(defthm cst-struct-declaration-list-branches-match-alt (implies (cst-matchp abnf::cst "struct-declaration-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "struct-declaration / struct-declaration-list struct-declaration")))
Theorem:
(defthm cst-struct-declaration-branches-match-alt (implies (cst-matchp abnf::cst "struct-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "specifier-qualifier-list struct-declarator-list \";\"")))
Theorem:
(defthm cst-specifier-qualifier-list-branches-match-alt (implies (cst-matchp abnf::cst "specifier-qualifier-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-specifier [ specifier-qualifier-list ]")))
Theorem:
(defthm cst-struct-declarator-list-branches-match-alt (implies (cst-matchp abnf::cst "struct-declarator-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "struct-declarator")))
Theorem:
(defthm cst-struct-declarator-branches-match-alt (implies (cst-matchp abnf::cst "struct-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declarator")))
Theorem:
(defthm cst-enum-specifier-branches-match-alt (implies (cst-matchp abnf::cst "enum-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"enum\" identifier")))
Theorem:
(defthm cst-declarator-branches-match-alt (implies (cst-matchp abnf::cst "declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ pointer ] direct-declarator")))
Theorem:
(defthm cst-direct-declarator-branches-match-alt (implies (cst-matchp abnf::cst "direct-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / \"(\" declarator \")\" / direct-declarator \"[\" [ integer-constant ] \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" %s\"void\" \")\" / direct-declarator \"(\" \")\"")))
Theorem:
(defthm cst-pointer-branches-match-alt (implies (cst-matchp abnf::cst "pointer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"*\" / \"*\" pointer")))
Theorem:
(defthm cst-parameter-type-list-branches-match-alt (implies (cst-matchp abnf::cst "parameter-type-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "parameter-list")))
Theorem:
(defthm cst-parameter-list-branches-match-alt (implies (cst-matchp abnf::cst "parameter-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "parameter-declaration / parameter-list \",\" parameter-declaration")))
Theorem:
(defthm cst-parameter-declaration-branches-match-alt (implies (cst-matchp abnf::cst "parameter-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration-specifiers declarator")))
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) "specifier-qualifier-list [ abstract-declarator ]")))
Theorem:
(defthm cst-abstract-declarator-branches-match-alt (implies (cst-matchp abnf::cst "abstract-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "pointer / [ pointer ] direct-abstract-declarator")))
Theorem:
(defthm cst-direct-abstract-declarator-branches-match-alt (implies (cst-matchp abnf::cst "direct-abstract-declarator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" abstract-declarator \")\" / [ direct-abstract-declarator ] \"[\" [ integer-constant ] \"]\"")))
Theorem:
(defthm cst-typedef-name-branches-match-alt (implies (cst-matchp abnf::cst "typedef-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier")))
Theorem:
(defthm cst-initializer-branches-match-alt (implies (cst-matchp abnf::cst "initializer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "assignment-expression / \"{\" initializer-list \"}\" / \"{\" initializer-list \",\" \"}\"")))
Theorem:
(defthm cst-initializer-list-branches-match-alt (implies (cst-matchp abnf::cst "initializer-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "initializer / initializer-list \",\" initializer")))
Theorem:
(defthm cst-statement-branches-match-alt (implies (cst-matchp abnf::cst "statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "labeled-statement / compound-statement / expression-statement / selection-statement / iteration-statement / jump-statement")))
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 / %s\"case\" constant-expression \":\" statement / %s\"default\" \":\" statement")))
Theorem:
(defthm cst-compound-statement-branches-match-alt (implies (cst-matchp abnf::cst "compound-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"{\" [ block-item-list ] \"}\"")))
Theorem:
(defthm cst-block-item-list-branches-match-alt (implies (cst-matchp abnf::cst "block-item-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "block-item / block-item-list block-item")))
Theorem:
(defthm cst-block-item-branches-match-alt (implies (cst-matchp abnf::cst "block-item") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration / statement")))
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) "[ expression ] \";\"")))
Theorem:
(defthm cst-selection-statement-branches-match-alt (implies (cst-matchp abnf::cst "selection-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"if\" \"(\" expression \")\" statement / %s\"if\" \"(\" expression \")\" statement %s\"else\" statement / %s\"switch\" \"(\" expression \")\" statement")))
Theorem:
(defthm cst-iteration-statement-branches-match-alt (implies (cst-matchp abnf::cst "iteration-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"while\" \"(\" expression \")\" statement / %s\"do\" statement %s\"while\" \"(\" expression \")\" \";\" / %s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement")))
Theorem:
(defthm cst-jump-statement-branches-match-alt (implies (cst-matchp abnf::cst "jump-statement") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"goto\" identifier \";\" / %s\"continue\" \";\" / %s\"break\" \";\" / %s\"return\" [ expression ] \";\"")))
Theorem:
(defthm cst-translation-unit-branches-match-alt (implies (cst-matchp abnf::cst "translation-unit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "external-declaration / translation-unit external-declaration")))
Theorem:
(defthm cst-external-declaration-branches-match-alt (implies (cst-matchp abnf::cst "external-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "function-definition / declaration")))
Theorem:
(defthm cst-function-definition-branches-match-alt (implies (cst-matchp abnf::cst "function-definition") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration-specifiers declarator compound-statement")))
Theorem:
(defthm cst-declaration-list-branches-match-alt (implies (cst-matchp abnf::cst "declaration-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration / declaration-list declaration")))
Theorem:
(defthm cst-horizontal-tab-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x9") (or (cst-list-list-conc-matchp abnf::cstss "%x9"))))
Theorem:
(defthm cst-line-feed-concs (implies (cst-list-list-alt-matchp abnf::cstss "%xA") (or (cst-list-list-conc-matchp abnf::cstss "%xA"))))
Theorem:
(defthm cst-vertical-tab-concs (implies (cst-list-list-alt-matchp abnf::cstss "%xB") (or (cst-list-list-conc-matchp abnf::cstss "%xB"))))
Theorem:
(defthm cst-form-feed-concs (implies (cst-list-list-alt-matchp abnf::cstss "%xC") (or (cst-list-list-conc-matchp abnf::cstss "%xC"))))
Theorem:
(defthm cst-carriage-return-concs (implies (cst-list-list-alt-matchp abnf::cstss "%xD") (or (cst-list-list-conc-matchp abnf::cstss "%xD"))))
Theorem:
(defthm cst-space-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x20") (or (cst-list-list-conc-matchp abnf::cstss "%x20"))))
Theorem:
(defthm cst-double-quote-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x22") (or (cst-list-list-conc-matchp abnf::cstss "%x22"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x0-9 / %xB-C / %xE-7F") (or (cst-list-list-conc-matchp abnf::cstss "%x0-9") (cst-list-list-conc-matchp abnf::cstss "%xB-C") (cst-list-list-conc-matchp abnf::cstss "%xE-7F"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x0-9 / %xB-C / %xE-29 / %x2B-7F") (or (cst-list-list-conc-matchp abnf::cstss "%x0-9") (cst-list-list-conc-matchp abnf::cstss "%xB-C") (cst-list-list-conc-matchp abnf::cstss "%xE-29") (cst-list-list-conc-matchp abnf::cstss "%x2B-7F"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x0-9 / %xB-C / %xE-29 / %x2B-2E / %x30-7F") (or (cst-list-list-conc-matchp abnf::cstss "%x0-9") (cst-list-list-conc-matchp abnf::cstss "%xB-C") (cst-list-list-conc-matchp abnf::cstss "%xE-29") (cst-list-list-conc-matchp abnf::cstss "%x2B-2E") (cst-list-list-conc-matchp abnf::cstss "%x30-7F"))))
Theorem:
(defthm cst-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x0-7F") (or (cst-list-list-conc-matchp abnf::cstss "%x0-7F"))))
Theorem:
(defthm cst-token-concs (implies (cst-list-list-alt-matchp abnf::cstss "keyword / identifier / constant / punctuator") (or (cst-list-list-conc-matchp abnf::cstss "keyword") (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "constant") (cst-list-list-conc-matchp abnf::cstss "punctuator"))))
Theorem:
(defthm cst-keyword-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"auto\" / %s\"break\" / %s\"case\" / %s\"char\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extern\" / %s\"float\" / %s\"for\" / %s\"goto\" / %s\"if\" / %s\"inline\" / %s\"int\" / %s\"long\" / %s\"register\" / %s\"restrict\" / %s\"return\" / %s\"short\" / %s\"signed\" / %s\"sizeof\" / %s\"static\" / %s\"struct\" / %s\"switch\" / %s\"typedef\" / %s\"union\" / %s\"unsigned\" / %s\"void\" / %s\"volatile\" / %s\"while\" / %s\"_Alignas\" / %s\"_Alignof\" / %s\"_Atomic\" / %s\"_Bool\" / %s\"_Complex\" / %s\"_Generic\" / %s\"_Imaginary\" / %s\"_Noreturn\" / %s\"_Static_assert\" / %s\"_Thread_local\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"") (cst-list-list-conc-matchp abnf::cstss "%s\"break\"") (cst-list-list-conc-matchp abnf::cstss "%s\"case\"") (cst-list-list-conc-matchp abnf::cstss "%s\"char\"") (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\"extern\"") (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\"goto\"") (cst-list-list-conc-matchp abnf::cstss "%s\"if\"") (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"") (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\"register\"") (cst-list-list-conc-matchp abnf::cstss "%s\"restrict\"") (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\"signed\"") (cst-list-list-conc-matchp abnf::cstss "%s\"sizeof\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"") (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"") (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"") (cst-list-list-conc-matchp abnf::cstss "%s\"union\"") (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"") (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 "%s\"_Alignas\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignof\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Complex\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Generic\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Imaginary\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Static_assert\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\""))))
Theorem:
(defthm cst-identifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier-nondigit / identifier identifier-nondigit / identifier digit") (or (cst-list-list-conc-matchp abnf::cstss "identifier-nondigit") (cst-list-list-conc-matchp abnf::cstss "identifier identifier-nondigit") (cst-list-list-conc-matchp abnf::cstss "identifier digit"))))
Theorem:
(defthm cst-identifier-nondigit-concs (implies (cst-list-list-alt-matchp abnf::cstss "nondigit") (or (cst-list-list-conc-matchp abnf::cstss "nondigit"))))
Theorem:
(defthm cst-nondigit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"_\" / %i\"a\" / %i\"b\" / %i\"c\" / %i\"d\" / %i\"e\" / %i\"f\" / %i\"g\" / %i\"h\" / %i\"i\" / %i\"j\" / %i\"k\" / %i\"l\" / %i\"m\" / %i\"n\" / %i\"o\" / %i\"p\" / %i\"q\" / %i\"r\" / %i\"s\" / %i\"t\" / %i\"u\" / %i\"v\" / %i\"w\" / %i\"x\" / %i\"y\" / %i\"z\"") (or (cst-list-list-conc-matchp abnf::cstss "\"_\"") (cst-list-list-conc-matchp abnf::cstss "%i\"a\"") (cst-list-list-conc-matchp abnf::cstss "%i\"b\"") (cst-list-list-conc-matchp abnf::cstss "%i\"c\"") (cst-list-list-conc-matchp abnf::cstss "%i\"d\"") (cst-list-list-conc-matchp abnf::cstss "%i\"e\"") (cst-list-list-conc-matchp abnf::cstss "%i\"f\"") (cst-list-list-conc-matchp abnf::cstss "%i\"g\"") (cst-list-list-conc-matchp abnf::cstss "%i\"h\"") (cst-list-list-conc-matchp abnf::cstss "%i\"i\"") (cst-list-list-conc-matchp abnf::cstss "%i\"j\"") (cst-list-list-conc-matchp abnf::cstss "%i\"k\"") (cst-list-list-conc-matchp abnf::cstss "%i\"l\"") (cst-list-list-conc-matchp abnf::cstss "%i\"m\"") (cst-list-list-conc-matchp abnf::cstss "%i\"n\"") (cst-list-list-conc-matchp abnf::cstss "%i\"o\"") (cst-list-list-conc-matchp abnf::cstss "%i\"p\"") (cst-list-list-conc-matchp abnf::cstss "%i\"q\"") (cst-list-list-conc-matchp abnf::cstss "%i\"r\"") (cst-list-list-conc-matchp abnf::cstss "%i\"s\"") (cst-list-list-conc-matchp abnf::cstss "%i\"t\"") (cst-list-list-conc-matchp abnf::cstss "%i\"u\"") (cst-list-list-conc-matchp abnf::cstss "%i\"v\"") (cst-list-list-conc-matchp abnf::cstss "%i\"w\"") (cst-list-list-conc-matchp abnf::cstss "%i\"x\"") (cst-list-list-conc-matchp abnf::cstss "%i\"y\"") (cst-list-list-conc-matchp abnf::cstss "%i\"z\""))))
Theorem:
(defthm cst-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"") (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\""))))
Theorem:
(defthm cst-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "integer-constant / enumeration-constant") (or (cst-list-list-conc-matchp abnf::cstss "integer-constant") (cst-list-list-conc-matchp abnf::cstss "enumeration-constant"))))
Theorem:
(defthm cst-integer-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "decimal-constant [ integer-suffix ] / octal-constant [ integer-suffix ] / hexadecimal-constant [ integer-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "decimal-constant [ integer-suffix ]") (cst-list-list-conc-matchp abnf::cstss "octal-constant [ integer-suffix ]") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-constant [ integer-suffix ]"))))
Theorem:
(defthm cst-decimal-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "nonzero-digit / decimal-constant digit") (or (cst-list-list-conc-matchp abnf::cstss "nonzero-digit") (cst-list-list-conc-matchp abnf::cstss "decimal-constant digit"))))
Theorem:
(defthm cst-octal-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / octal-constant octal-digit") (or (cst-list-list-conc-matchp abnf::cstss "\"0\"") (cst-list-list-conc-matchp abnf::cstss "octal-constant octal-digit"))))
Theorem:
(defthm cst-hexadecimal-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "hexadecimal-prefix hexadecimal-digit / hexadecimal-constant hexadecimal-digit") (or (cst-list-list-conc-matchp abnf::cstss "hexadecimal-prefix hexadecimal-digit") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-constant hexadecimal-digit"))))
Theorem:
(defthm cst-hexadecimal-prefix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"0x\"") (or (cst-list-list-conc-matchp abnf::cstss "%i\"0x\""))))
Theorem:
(defthm cst-nonzero-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-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-hexadecimal-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / %i\"a\" / %i\"b\" / %i\"c\" / %i\"d\" / %i\"e\" / %i\"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 "%i\"a\"") (cst-list-list-conc-matchp abnf::cstss "%i\"b\"") (cst-list-list-conc-matchp abnf::cstss "%i\"c\"") (cst-list-list-conc-matchp abnf::cstss "%i\"d\"") (cst-list-list-conc-matchp abnf::cstss "%i\"e\"") (cst-list-list-conc-matchp abnf::cstss "%i\"f\""))))
Theorem:
(defthm cst-integer-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "unsigned-suffix [ long-suffix ] / unsigned-suffix [ long-long-suffix ] / long-suffix [ unsigned-suffix ] / long-long-suffix [ unsigned-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "unsigned-suffix [ long-suffix ]") (cst-list-list-conc-matchp abnf::cstss "unsigned-suffix [ long-long-suffix ]") (cst-list-list-conc-matchp abnf::cstss "long-suffix [ unsigned-suffix ]") (cst-list-list-conc-matchp abnf::cstss "long-long-suffix [ unsigned-suffix ]"))))
Theorem:
(defthm cst-unsigned-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"u\"") (or (cst-list-list-conc-matchp abnf::cstss "%i\"u\""))))
Theorem:
(defthm cst-long-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"l\"") (or (cst-list-list-conc-matchp abnf::cstss "%i\"l\""))))
Theorem:
(defthm cst-long-long-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"ll\" / %s\"LL\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"ll\"") (cst-list-list-conc-matchp abnf::cstss "%s\"LL\""))))
Theorem:
(defthm cst-enumeration-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))
Theorem:
(defthm cst-punctuator-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 "\"%=\"") (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-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ carriage-return ] line-feed") (or (cst-list-list-conc-matchp abnf::cstss "[ carriage-return ] line-feed"))))
Theorem:
(defthm cst-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "block-comment / line-comment") (or (cst-list-list-conc-matchp abnf::cstss "block-comment") (cst-list-list-conc-matchp abnf::cstss "line-comment"))))
Theorem:
(defthm cst-block-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"/*\" rest-of-block-comment") (or (cst-list-list-conc-matchp abnf::cstss "\"/*\" rest-of-block-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"*\" rest-of-block-comment-after-star / not-star-or-line-feed-or-carriage-return rest-of-block-comment / new-line rest-of-block-comment") (or (cst-list-list-conc-matchp abnf::cstss "\"*\" rest-of-block-comment-after-star") (cst-list-list-conc-matchp abnf::cstss "not-star-or-line-feed-or-carriage-return rest-of-block-comment") (cst-list-list-conc-matchp abnf::cstss "new-line rest-of-block-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-after-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"/\" / \"*\" rest-of-block-comment-after-star / not-star-or-slash-or-line-feed-or-carriage-return rest-of-block-comment / new-line rest-of-block-comment") (or (cst-list-list-conc-matchp abnf::cstss "\"/\"") (cst-list-list-conc-matchp abnf::cstss "\"*\" rest-of-block-comment-after-star") (cst-list-list-conc-matchp abnf::cstss "not-star-or-slash-or-line-feed-or-carriage-return rest-of-block-comment") (cst-list-list-conc-matchp abnf::cstss "new-line rest-of-block-comment"))))
Theorem:
(defthm cst-line-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"//\" *not-line-feed-or-carriage-return") (or (cst-list-list-conc-matchp abnf::cstss "\"//\" *not-line-feed-or-carriage-return"))))
Theorem:
(defthm cst-white-space-concs (implies (cst-list-list-alt-matchp abnf::cstss "space / horizontal-tab / vertical-tab / form-feed / new-line") (or (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "horizontal-tab") (cst-list-list-conc-matchp abnf::cstss "vertical-tab") (cst-list-list-conc-matchp abnf::cstss "form-feed") (cst-list-list-conc-matchp abnf::cstss "new-line"))))
Theorem:
(defthm cst-lexeme-concs (implies (cst-list-list-alt-matchp abnf::cstss "token / comment / white-space") (or (cst-list-list-conc-matchp abnf::cstss "token") (cst-list-list-conc-matchp abnf::cstss "comment") (cst-list-list-conc-matchp abnf::cstss "white-space"))))
Theorem:
(defthm cst-primary-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / constant \"(\" expression \")\"") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "constant \"(\" expression \")\""))))
Theorem:
(defthm cst-postfix-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "primary-expression / postfix-expression \"[\" expression \"]\" / identifier \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\"") (or (cst-list-list-conc-matchp abnf::cstss "primary-expression") (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"[\" expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "identifier \"(\" [ argument-expression-list ] \")\"") (cst-list-list-conc-matchp abnf::cstss "postfix-expression \".\" identifier") (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"->\" identifier") (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"++\"") (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"--\""))))
Theorem:
(defthm cst-argument-expression-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "assignment-expression / argument-expression-list \",\" assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "assignment-expression") (cst-list-list-conc-matchp abnf::cstss "argument-expression-list \",\" assignment-expression"))))
Theorem:
(defthm cst-unary-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "postfix-expression / \"++\" unary-expression / \"--\" unary-expression / unary-operator cast-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 "unary-operator cast-expression"))))
Theorem:
(defthm cst-unary-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 "\"!\""))))
Theorem:
(defthm cst-cast-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "unary-expression / \"(\" type-name \")\" cast-expression") (or (cst-list-list-conc-matchp abnf::cstss "unary-expression") (cst-list-list-conc-matchp abnf::cstss "\"(\" type-name \")\" cast-expression"))))
Theorem:
(defthm cst-multiplicative-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "cast-expression / multiplicative-expression \"*\" cast-expression / multiplicative-expression \"/\" cast-expression / multiplicative-expression \"%\" cast-expression") (or (cst-list-list-conc-matchp abnf::cstss "cast-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"*\" cast-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"/\" cast-expression") (cst-list-list-conc-matchp abnf::cstss "multiplicative-expression \"%\" cast-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") (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"))))
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") (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"))))
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-logical-and-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "inclusive-or-expression / logical-and-expression \"&&\" inclusive-or-expression") (or (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression") (cst-list-list-conc-matchp abnf::cstss "logical-and-expression \"&&\" inclusive-or-expression"))))
Theorem:
(defthm cst-logical-or-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "logical-and-expression / logical-or-expression \"||\" logical-and-expression") (or (cst-list-list-conc-matchp abnf::cstss "logical-and-expression") (cst-list-list-conc-matchp abnf::cstss "logical-or-expression \"||\" logical-and-expression"))))
Theorem:
(defthm cst-conditional-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "logical-or-expression / logical-or-expression \"?\" expression \":\" conditional-expression") (or (cst-list-list-conc-matchp abnf::cstss "logical-or-expression") (cst-list-list-conc-matchp abnf::cstss "logical-or-expression \"?\" expression \":\" conditional-expression"))))
Theorem:
(defthm cst-assignment-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-expression / unary-expression assignment-operator assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "conditional-expression") (cst-list-list-conc-matchp abnf::cstss "unary-expression assignment-operator assignment-expression"))))
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 "\"|=\""))))
Theorem:
(defthm cst-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "assignment-expression"))))
Theorem:
(defthm cst-constant-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "conditional-expression") (or (cst-list-list-conc-matchp abnf::cstss "conditional-expression"))))
Theorem:
(defthm cst-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "declaration-specifiers [ init-declarator-list ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers [ init-declarator-list ] \";\""))))
Theorem:
(defthm cst-declaration-specifiers-concs (implies (cst-list-list-alt-matchp abnf::cstss "storage-class-specifier [ declaration-specifiers ] / type-specifier [ declaration-specifiers ]") (or (cst-list-list-conc-matchp abnf::cstss "storage-class-specifier [ declaration-specifiers ]") (cst-list-list-conc-matchp abnf::cstss "type-specifier [ declaration-specifiers ]"))))
Theorem:
(defthm cst-init-declarator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "init-declarator") (or (cst-list-list-conc-matchp abnf::cstss "init-declarator"))))
Theorem:
(defthm cst-init-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "declarator / declarator \"=\" initializer") (or (cst-list-list-conc-matchp abnf::cstss "declarator") (cst-list-list-conc-matchp abnf::cstss "declarator \"=\" initializer"))))
Theorem:
(defthm cst-storage-class-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"extern\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"extern\""))))
Theorem:
(defthm cst-type-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"void\" / %s\"char\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"float\" / %s\"double\" / %s\"signed\" / %s\"unsigned\" / %s\"_Bool\" / struct-or-union-specifier / enum-specifier / typedef-name") (or (cst-list-list-conc-matchp abnf::cstss "%s\"void\"") (cst-list-list-conc-matchp abnf::cstss "%s\"char\"") (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\"float\"") (cst-list-list-conc-matchp abnf::cstss "%s\"double\"") (cst-list-list-conc-matchp abnf::cstss "%s\"signed\"") (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"") (cst-list-list-conc-matchp abnf::cstss "struct-or-union-specifier") (cst-list-list-conc-matchp abnf::cstss "enum-specifier") (cst-list-list-conc-matchp abnf::cstss "typedef-name"))))
Theorem:
(defthm cst-struct-or-union-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "struct-or-union [ identifier ] \"{\" struct-declaration-list \"}\" / struct-or-union identifier") (or (cst-list-list-conc-matchp abnf::cstss "struct-or-union [ identifier ] \"{\" struct-declaration-list \"}\"") (cst-list-list-conc-matchp abnf::cstss "struct-or-union identifier"))))
Theorem:
(defthm cst-struct-or-union-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"struct\" / %s\"union\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"") (cst-list-list-conc-matchp abnf::cstss "%s\"union\""))))
Theorem:
(defthm cst-struct-declaration-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "struct-declaration / struct-declaration-list struct-declaration") (or (cst-list-list-conc-matchp abnf::cstss "struct-declaration") (cst-list-list-conc-matchp abnf::cstss "struct-declaration-list struct-declaration"))))
Theorem:
(defthm cst-struct-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "specifier-qualifier-list struct-declarator-list \";\"") (or (cst-list-list-conc-matchp abnf::cstss "specifier-qualifier-list struct-declarator-list \";\""))))
Theorem:
(defthm cst-specifier-qualifier-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-specifier [ specifier-qualifier-list ]") (or (cst-list-list-conc-matchp abnf::cstss "type-specifier [ specifier-qualifier-list ]"))))
Theorem:
(defthm cst-struct-declarator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "struct-declarator") (or (cst-list-list-conc-matchp abnf::cstss "struct-declarator"))))
Theorem:
(defthm cst-struct-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "declarator") (or (cst-list-list-conc-matchp abnf::cstss "declarator"))))
Theorem:
(defthm cst-enum-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"enum\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" identifier"))))
Theorem:
(defthm cst-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ pointer ] direct-declarator") (or (cst-list-list-conc-matchp abnf::cstss "[ pointer ] direct-declarator"))))
Theorem:
(defthm cst-direct-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / \"(\" declarator \")\" / direct-declarator \"[\" [ integer-constant ] \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" %s\"void\" \")\" / direct-declarator \"(\" \")\"") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "\"(\" declarator \")\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"[\" [ integer-constant ] \"]\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"(\" parameter-type-list \")\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"(\" %s\"void\" \")\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"(\" \")\""))))
Theorem:
(defthm cst-pointer-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"*\" / \"*\" pointer") (or (cst-list-list-conc-matchp abnf::cstss "\"*\"") (cst-list-list-conc-matchp abnf::cstss "\"*\" pointer"))))
Theorem:
(defthm cst-parameter-type-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "parameter-list") (or (cst-list-list-conc-matchp abnf::cstss "parameter-list"))))
Theorem:
(defthm cst-parameter-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "parameter-declaration / parameter-list \",\" parameter-declaration") (or (cst-list-list-conc-matchp abnf::cstss "parameter-declaration") (cst-list-list-conc-matchp abnf::cstss "parameter-list \",\" parameter-declaration"))))
Theorem:
(defthm cst-parameter-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "declaration-specifiers declarator") (or (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers declarator"))))
Theorem:
(defthm cst-type-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "specifier-qualifier-list [ abstract-declarator ]") (or (cst-list-list-conc-matchp abnf::cstss "specifier-qualifier-list [ abstract-declarator ]"))))
Theorem:
(defthm cst-abstract-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "pointer / [ pointer ] direct-abstract-declarator") (or (cst-list-list-conc-matchp abnf::cstss "pointer") (cst-list-list-conc-matchp abnf::cstss "[ pointer ] direct-abstract-declarator"))))
Theorem:
(defthm cst-direct-abstract-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" abstract-declarator \")\" / [ direct-abstract-declarator ] \"[\" [ integer-constant ] \"]\"") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" abstract-declarator \")\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"[\" [ integer-constant ] \"]\""))))
Theorem:
(defthm cst-typedef-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))
Theorem:
(defthm cst-initializer-concs (implies (cst-list-list-alt-matchp abnf::cstss "assignment-expression / \"{\" initializer-list \"}\" / \"{\" initializer-list \",\" \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "assignment-expression") (cst-list-list-conc-matchp abnf::cstss "\"{\" initializer-list \"}\"") (cst-list-list-conc-matchp abnf::cstss "\"{\" initializer-list \",\" \"}\""))))
Theorem:
(defthm cst-initializer-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "initializer / initializer-list \",\" initializer") (or (cst-list-list-conc-matchp abnf::cstss "initializer") (cst-list-list-conc-matchp abnf::cstss "initializer-list \",\" initializer"))))
Theorem:
(defthm cst-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "labeled-statement / compound-statement / expression-statement / selection-statement / iteration-statement / jump-statement") (or (cst-list-list-conc-matchp abnf::cstss "labeled-statement") (cst-list-list-conc-matchp abnf::cstss "compound-statement") (cst-list-list-conc-matchp abnf::cstss "expression-statement") (cst-list-list-conc-matchp abnf::cstss "selection-statement") (cst-list-list-conc-matchp abnf::cstss "iteration-statement") (cst-list-list-conc-matchp abnf::cstss "jump-statement"))))
Theorem:
(defthm cst-labeled-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier \":\" statement / %s\"case\" constant-expression \":\" statement / %s\"default\" \":\" statement") (or (cst-list-list-conc-matchp abnf::cstss "identifier \":\" statement") (cst-list-list-conc-matchp abnf::cstss "%s\"case\" constant-expression \":\" statement") (cst-list-list-conc-matchp abnf::cstss "%s\"default\" \":\" statement"))))
Theorem:
(defthm cst-compound-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"{\" [ block-item-list ] \"}\"") (or (cst-list-list-conc-matchp abnf::cstss "\"{\" [ block-item-list ] \"}\""))))
Theorem:
(defthm cst-block-item-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "block-item / block-item-list block-item") (or (cst-list-list-conc-matchp abnf::cstss "block-item") (cst-list-list-conc-matchp abnf::cstss "block-item-list block-item"))))
Theorem:
(defthm cst-block-item-concs (implies (cst-list-list-alt-matchp abnf::cstss "declaration / statement") (or (cst-list-list-conc-matchp abnf::cstss "declaration") (cst-list-list-conc-matchp abnf::cstss "statement"))))
Theorem:
(defthm cst-expression-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ expression ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "[ expression ] \";\""))))
Theorem:
(defthm cst-selection-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement / %s\"if\" \"(\" expression \")\" statement %s\"else\" statement / %s\"switch\" \"(\" expression \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement") (cst-list-list-conc-matchp abnf::cstss "%s\"if\" \"(\" expression \")\" statement %s\"else\" statement") (cst-list-list-conc-matchp abnf::cstss "%s\"switch\" \"(\" expression \")\" statement"))))
Theorem:
(defthm cst-iteration-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement / %s\"do\" statement %s\"while\" \"(\" expression \")\" \";\" / %s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement") (or (cst-list-list-conc-matchp abnf::cstss "%s\"while\" \"(\" expression \")\" statement") (cst-list-list-conc-matchp abnf::cstss "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement"))))
Theorem:
(defthm cst-jump-statement-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"goto\" identifier \";\" / %s\"continue\" \";\" / %s\"break\" \";\" / %s\"return\" [ expression ] \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"goto\" identifier \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"continue\" \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"break\" \";\"") (cst-list-list-conc-matchp abnf::cstss "%s\"return\" [ expression ] \";\""))))
Theorem:
(defthm cst-translation-unit-concs (implies (cst-list-list-alt-matchp abnf::cstss "external-declaration / translation-unit external-declaration") (or (cst-list-list-conc-matchp abnf::cstss "external-declaration") (cst-list-list-conc-matchp abnf::cstss "translation-unit external-declaration"))))
Theorem:
(defthm cst-external-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "function-definition / declaration") (or (cst-list-list-conc-matchp abnf::cstss "function-definition") (cst-list-list-conc-matchp abnf::cstss "declaration"))))
Theorem:
(defthm cst-function-definition-concs (implies (cst-list-list-alt-matchp abnf::cstss "declaration-specifiers declarator compound-statement") (or (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers declarator compound-statement"))))
Theorem:
(defthm cst-declaration-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "declaration / declaration-list declaration") (or (cst-list-list-conc-matchp abnf::cstss "declaration") (cst-list-list-conc-matchp abnf::cstss "declaration-list declaration"))))
Theorem:
(defthm cst-horizontal-tab-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x9") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x9"))))
Theorem:
(defthm cst-line-feed-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xA") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xA"))))
Theorem:
(defthm cst-vertical-tab-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xB") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xB"))))
Theorem:
(defthm cst-form-feed-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xC") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xC"))))
Theorem:
(defthm cst-carriage-return-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xD") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xD"))))
Theorem:
(defthm cst-space-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x20") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x20"))))
Theorem:
(defthm cst-double-quote-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x22") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x22"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x0-9"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xB-C") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xB-C"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xE-7F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xE-7F"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x0-9"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xB-C") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xB-C"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xE-29") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xE-29"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-7F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x2B-7F"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x0-9"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xB-C") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xB-C"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xE-29") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xE-29"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-2E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x2B-2E"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x30-7F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x30-7F"))))
Theorem:
(defthm cst-character-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x0-7F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x0-7F"))))
Theorem:
(defthm cst-token-conc1-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-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-token-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "constant"))))
Theorem:
(defthm cst-token-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "punctuator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "punctuator"))))
Theorem:
(defthm cst-keyword-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"auto\""))))
Theorem:
(defthm cst-keyword-conc2-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-conc3-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-conc4-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-conc5-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-conc6-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-conc7-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-conc8-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-conc9-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-conc10-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-conc11-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-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"extern\""))))
Theorem:
(defthm cst-keyword-conc13-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-conc14-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-conc15-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-conc16-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-conc17-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"inline\""))))
Theorem:
(defthm cst-keyword-conc18-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-conc19-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-conc20-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"register\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"register\""))))
Theorem:
(defthm cst-keyword-conc21-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"restrict\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"restrict\""))))
Theorem:
(defthm cst-keyword-conc22-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-conc23-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-conc24-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"signed\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"signed\""))))
Theorem:
(defthm cst-keyword-conc25-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sizeof\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"sizeof\""))))
Theorem:
(defthm cst-keyword-conc26-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-conc27-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"struct\""))))
Theorem:
(defthm cst-keyword-conc28-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-conc29-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"typedef\""))))
Theorem:
(defthm cst-keyword-conc30-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"union\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"union\""))))
Theorem:
(defthm cst-keyword-conc31-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"unsigned\""))))
Theorem:
(defthm cst-keyword-conc32-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-conc33-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-conc34-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-conc35-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignas\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Alignas\""))))
Theorem:
(defthm cst-keyword-conc36-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignof\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Alignof\""))))
Theorem:
(defthm cst-keyword-conc37-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Atomic\""))))
Theorem:
(defthm cst-keyword-conc38-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Bool\""))))
Theorem:
(defthm cst-keyword-conc39-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Complex\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Complex\""))))
Theorem:
(defthm cst-keyword-conc40-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Generic\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Generic\""))))
Theorem:
(defthm cst-keyword-conc41-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Imaginary\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Imaginary\""))))
Theorem:
(defthm cst-keyword-conc42-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Noreturn\""))))
Theorem:
(defthm cst-keyword-conc43-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Static_assert\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Static_assert\""))))
Theorem:
(defthm cst-keyword-conc44-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Thread_local\""))))
Theorem:
(defthm cst-identifier-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "identifier-nondigit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "identifier-nondigit"))))
Theorem:
(defthm cst-identifier-nondigit-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "nondigit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "nondigit"))))
Theorem:
(defthm cst-nondigit-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-nondigit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"a\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"a\""))))
Theorem:
(defthm cst-nondigit-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"b\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"b\""))))
Theorem:
(defthm cst-nondigit-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"c\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"c\""))))
Theorem:
(defthm cst-nondigit-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"d\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"d\""))))
Theorem:
(defthm cst-nondigit-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"e\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"e\""))))
Theorem:
(defthm cst-nondigit-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"f\""))))
Theorem:
(defthm cst-nondigit-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"g\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"g\""))))
Theorem:
(defthm cst-nondigit-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"h\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"h\""))))
Theorem:
(defthm cst-nondigit-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"i\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"i\""))))
Theorem:
(defthm cst-nondigit-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"j\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"j\""))))
Theorem:
(defthm cst-nondigit-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"k\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"k\""))))
Theorem:
(defthm cst-nondigit-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"l\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"l\""))))
Theorem:
(defthm cst-nondigit-conc14-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"m\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"m\""))))
Theorem:
(defthm cst-nondigit-conc15-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"n\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"n\""))))
Theorem:
(defthm cst-nondigit-conc16-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"o\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"o\""))))
Theorem:
(defthm cst-nondigit-conc17-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"p\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"p\""))))
Theorem:
(defthm cst-nondigit-conc18-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"q\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"q\""))))
Theorem:
(defthm cst-nondigit-conc19-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"r\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"r\""))))
Theorem:
(defthm cst-nondigit-conc20-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"s\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"s\""))))
Theorem:
(defthm cst-nondigit-conc21-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"t\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"t\""))))
Theorem:
(defthm cst-nondigit-conc22-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"u\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"u\""))))
Theorem:
(defthm cst-nondigit-conc23-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"v\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"v\""))))
Theorem:
(defthm cst-nondigit-conc24-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"w\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"w\""))))
Theorem:
(defthm cst-nondigit-conc25-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"x\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"x\""))))
Theorem:
(defthm cst-nondigit-conc26-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"y\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"y\""))))
Theorem:
(defthm cst-nondigit-conc27-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"z\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"z\""))))
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 "\"1\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"1\""))))
Theorem:
(defthm cst-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-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-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-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-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-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-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-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-constant-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "integer-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "integer-constant"))))
Theorem:
(defthm cst-constant-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "enumeration-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enumeration-constant"))))
Theorem:
(defthm cst-decimal-constant-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "nonzero-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "nonzero-digit"))))
Theorem:
(defthm cst-octal-constant-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-hexadecimal-prefix-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"0x\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"0x\""))))
Theorem:
(defthm cst-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-digit-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"a\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"a\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"b\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"b\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"c\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"c\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"d\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"d\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"e\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"e\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc14-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"f\""))))
Theorem:
(defthm cst-unsigned-suffix-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"u\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"u\""))))
Theorem:
(defthm cst-long-suffix-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%i\"l\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%i\"l\""))))
Theorem:
(defthm cst-long-long-suffix-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"ll\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"ll\""))))
Theorem:
(defthm cst-long-long-suffix-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"LL\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"LL\""))))
Theorem:
(defthm cst-enumeration-constant-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-conc39-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-punctuator-conc40-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-punctuator-conc41-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-punctuator-conc42-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-punctuator-conc43-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-punctuator-conc44-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-punctuator-conc45-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-punctuator-conc46-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-punctuator-conc47-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-punctuator-conc48-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-punctuator-conc49-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-punctuator-conc50-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-punctuator-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-punctuator-conc52-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-punctuator-conc53-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-punctuator-conc54-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-comment-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "block-comment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block-comment"))))
Theorem:
(defthm cst-comment-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-comment") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-after-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-white-space-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "space") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "space"))))
Theorem:
(defthm cst-white-space-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "horizontal-tab"))))
Theorem:
(defthm cst-white-space-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "vertical-tab") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "vertical-tab"))))
Theorem:
(defthm cst-white-space-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "form-feed") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "form-feed"))))
Theorem:
(defthm cst-white-space-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "new-line"))))
Theorem:
(defthm cst-lexeme-conc1-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-lexeme-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-lexeme-conc3-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-primary-expression-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-postfix-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "primary-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "primary-expression"))))
Theorem:
(defthm cst-argument-expression-list-conc1-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-unary-expression-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-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-unary-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-unary-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-unary-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-unary-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-unary-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-cast-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-multiplicative-expression-conc1-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-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-logical-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-logical-or-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "logical-and-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "logical-and-expression"))))
Theorem:
(defthm cst-conditional-expression-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "logical-or-expression") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "logical-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-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-expression-conc-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-constant-expression-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-init-declarator-list-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "init-declarator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "init-declarator"))))
Theorem:
(defthm cst-init-declarator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "declarator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "declarator"))))
Theorem:
(defthm cst-storage-class-specifier-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"extern\""))))
Theorem:
(defthm cst-type-specifier-conc1-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-type-specifier-conc2-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-type-specifier-conc3-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-type-specifier-conc4-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-type-specifier-conc5-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-type-specifier-conc6-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-type-specifier-conc7-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-type-specifier-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"signed\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"signed\""))))
Theorem:
(defthm cst-type-specifier-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"unsigned\""))))
Theorem:
(defthm cst-type-specifier-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Bool\""))))
Theorem:
(defthm cst-type-specifier-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "struct-or-union-specifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "struct-or-union-specifier"))))
Theorem:
(defthm cst-type-specifier-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "enum-specifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enum-specifier"))))
Theorem:
(defthm cst-type-specifier-conc13-matching (implies (cst-list-list-conc-matchp abnf::cstss "typedef-name") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "typedef-name"))))
Theorem:
(defthm cst-struct-or-union-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"struct\""))))
Theorem:
(defthm cst-struct-or-union-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"union\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"union\""))))
Theorem:
(defthm cst-struct-declaration-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "struct-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "struct-declaration"))))
Theorem:
(defthm cst-struct-declarator-list-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "struct-declarator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "struct-declarator"))))
Theorem:
(defthm cst-struct-declarator-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "declarator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "declarator"))))
Theorem:
(defthm cst-direct-declarator-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-pointer-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-parameter-type-list-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "parameter-list") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "parameter-list"))))
Theorem:
(defthm cst-parameter-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "parameter-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "parameter-declaration"))))
Theorem:
(defthm cst-abstract-declarator-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "pointer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "pointer"))))
Theorem:
(defthm cst-typedef-name-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-initializer-conc1-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-initializer-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "initializer") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "initializer"))))
Theorem:
(defthm cst-statement-conc1-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-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "compound-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "compound-statement"))))
Theorem:
(defthm cst-statement-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-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "selection-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "selection-statement"))))
Theorem:
(defthm cst-statement-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "iteration-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "iteration-statement"))))
Theorem:
(defthm cst-statement-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "jump-statement") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "jump-statement"))))
Theorem:
(defthm cst-block-item-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "block-item") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "block-item"))))
Theorem:
(defthm cst-block-item-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "declaration"))))
Theorem:
(defthm cst-block-item-conc2-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-translation-unit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "external-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "external-declaration"))))
Theorem:
(defthm cst-external-declaration-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "function-definition") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "function-definition"))))
Theorem:
(defthm cst-external-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "declaration"))))
Theorem:
(defthm cst-declaration-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "declaration"))))
Theorem:
(defthm cst-horizontal-tab-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x9") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x9"))))
Theorem:
(defthm cst-line-feed-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xA") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xA"))))
Theorem:
(defthm cst-vertical-tab-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xB") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xB"))))
Theorem:
(defthm cst-form-feed-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xC") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xC"))))
Theorem:
(defthm cst-carriage-return-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xD") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xD"))))
Theorem:
(defthm cst-space-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x20") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x20"))))
Theorem:
(defthm cst-double-quote-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x22") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x22"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x0-9") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x0-9"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xB-C") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xB-C"))))
Theorem:
(defthm cst-not-line-feed-or-carriage-return-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xE-7F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xE-7F"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x0-9") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x0-9"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xB-C") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xB-C"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xE-29") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xE-29"))))
Theorem:
(defthm cst-not-star-or-line-feed-or-carriage-return-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x2B-7F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x2B-7F"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x0-9") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x0-9"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xB-C") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xB-C"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xE-29") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xE-29"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x2B-2E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x2B-2E"))))
Theorem:
(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x30-7F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x30-7F"))))
Theorem:
(defthm cst-character-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x0-7F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x0-7F"))))
Theorem:
(defthm cst-token-conc1-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-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-token-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "constant"))))
Theorem:
(defthm cst-token-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "punctuator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "punctuator"))))
Theorem:
(defthm cst-keyword-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"auto\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"auto\""))))
Theorem:
(defthm cst-keyword-conc2-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-conc3-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-conc4-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-conc5-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-conc6-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-conc7-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-conc8-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-conc9-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-conc10-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-conc11-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-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"extern\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"extern\""))))
Theorem:
(defthm cst-keyword-conc13-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-conc14-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-conc15-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-conc16-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-conc17-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"inline\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"inline\""))))
Theorem:
(defthm cst-keyword-conc18-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-conc19-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-conc20-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"register\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"register\""))))
Theorem:
(defthm cst-keyword-conc21-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"restrict\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"restrict\""))))
Theorem:
(defthm cst-keyword-conc22-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-conc23-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-conc24-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"signed\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"signed\""))))
Theorem:
(defthm cst-keyword-conc25-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"sizeof\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"sizeof\""))))
Theorem:
(defthm cst-keyword-conc26-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-conc27-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"struct\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"struct\""))))
Theorem:
(defthm cst-keyword-conc28-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-conc29-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"typedef\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"typedef\""))))
Theorem:
(defthm cst-keyword-conc30-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"union\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"union\""))))
Theorem:
(defthm cst-keyword-conc31-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"unsigned\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"unsigned\""))))
Theorem:
(defthm cst-keyword-conc32-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-conc33-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-conc34-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-conc35-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Alignas\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Alignas\""))))
Theorem:
(defthm cst-keyword-conc36-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Alignof\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Alignof\""))))
Theorem:
(defthm cst-keyword-conc37-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Atomic\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Atomic\""))))
Theorem:
(defthm cst-keyword-conc38-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Bool\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Bool\""))))
Theorem:
(defthm cst-keyword-conc39-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Complex\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Complex\""))))
Theorem:
(defthm cst-keyword-conc40-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Generic\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Generic\""))))
Theorem:
(defthm cst-keyword-conc41-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Imaginary\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Imaginary\""))))
Theorem:
(defthm cst-keyword-conc42-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Noreturn\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Noreturn\""))))
Theorem:
(defthm cst-keyword-conc43-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Static_assert\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Static_assert\""))))
Theorem:
(defthm cst-keyword-conc44-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Thread_local\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Thread_local\""))))
Theorem:
(defthm cst-identifier-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "identifier-nondigit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "identifier-nondigit"))))
Theorem:
(defthm cst-identifier-nondigit-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "nondigit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "nondigit"))))
Theorem:
(defthm cst-nondigit-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-nondigit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"a\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"a\""))))
Theorem:
(defthm cst-nondigit-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"b\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"b\""))))
Theorem:
(defthm cst-nondigit-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"c\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"c\""))))
Theorem:
(defthm cst-nondigit-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"d\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"d\""))))
Theorem:
(defthm cst-nondigit-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"e\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"e\""))))
Theorem:
(defthm cst-nondigit-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"f\""))))
Theorem:
(defthm cst-nondigit-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"g\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"g\""))))
Theorem:
(defthm cst-nondigit-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"h\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"h\""))))
Theorem:
(defthm cst-nondigit-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"i\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"i\""))))
Theorem:
(defthm cst-nondigit-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"j\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"j\""))))
Theorem:
(defthm cst-nondigit-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"k\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"k\""))))
Theorem:
(defthm cst-nondigit-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"l\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"l\""))))
Theorem:
(defthm cst-nondigit-conc14-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"m\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"m\""))))
Theorem:
(defthm cst-nondigit-conc15-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"n\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"n\""))))
Theorem:
(defthm cst-nondigit-conc16-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"o\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"o\""))))
Theorem:
(defthm cst-nondigit-conc17-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"p\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"p\""))))
Theorem:
(defthm cst-nondigit-conc18-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"q\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"q\""))))
Theorem:
(defthm cst-nondigit-conc19-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"r\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"r\""))))
Theorem:
(defthm cst-nondigit-conc20-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"s\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"s\""))))
Theorem:
(defthm cst-nondigit-conc21-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"t\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"t\""))))
Theorem:
(defthm cst-nondigit-conc22-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"u\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"u\""))))
Theorem:
(defthm cst-nondigit-conc23-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"v\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"v\""))))
Theorem:
(defthm cst-nondigit-conc24-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"w\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"w\""))))
Theorem:
(defthm cst-nondigit-conc25-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"x\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"x\""))))
Theorem:
(defthm cst-nondigit-conc26-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"y\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"y\""))))
Theorem:
(defthm cst-nondigit-conc27-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"z\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"z\""))))
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 "\"1\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"1\""))))
Theorem:
(defthm cst-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-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-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-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-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-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-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-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-constant-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "integer-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "integer-constant"))))
Theorem:
(defthm cst-constant-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "enumeration-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enumeration-constant"))))
Theorem:
(defthm cst-decimal-constant-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "nonzero-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "nonzero-digit"))))
Theorem:
(defthm cst-octal-constant-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-hexadecimal-prefix-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"0x\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"0x\""))))
Theorem:
(defthm cst-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-nonzero-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-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-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-hexadecimal-digit-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"a\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"a\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"b\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"b\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"c\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"c\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"d\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"d\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"e\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"e\""))))
Theorem:
(defthm cst-hexadecimal-digit-conc14-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"f\""))))
Theorem:
(defthm cst-unsigned-suffix-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"u\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"u\""))))
Theorem:
(defthm cst-long-suffix-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%i\"l\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%i\"l\""))))
Theorem:
(defthm cst-long-long-suffix-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"ll\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"ll\""))))
Theorem:
(defthm cst-long-long-suffix-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"LL\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"LL\""))))
Theorem:
(defthm cst-enumeration-constant-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-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-punctuator-conc39-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+=\""))))
Theorem:
(defthm cst-punctuator-conc40-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-=\""))))
Theorem:
(defthm cst-punctuator-conc41-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<<=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<<=\""))))
Theorem:
(defthm cst-punctuator-conc42-rep-matching (implies (cst-list-rep-matchp abnf::csts "\">>=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\">>=\""))))
Theorem:
(defthm cst-punctuator-conc43-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"&=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"&=\""))))
Theorem:
(defthm cst-punctuator-conc44-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"^=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"^=\""))))
Theorem:
(defthm cst-punctuator-conc45-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"|=\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"|=\""))))
Theorem:
(defthm cst-punctuator-conc46-rep-matching (implies (cst-list-rep-matchp abnf::csts "\",\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\",\""))))
Theorem:
(defthm cst-punctuator-conc47-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"#\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"#\""))))
Theorem:
(defthm cst-punctuator-conc48-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"##\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"##\""))))
Theorem:
(defthm cst-punctuator-conc49-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"<:\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"<:\""))))
Theorem:
(defthm cst-punctuator-conc50-rep-matching (implies (cst-list-rep-matchp abnf::csts "\":>\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\":>\""))))
Theorem:
(defthm cst-punctuator-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-punctuator-conc52-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%>\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%>\""))))
Theorem:
(defthm cst-punctuator-conc53-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%:\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%:\""))))
Theorem:
(defthm cst-punctuator-conc54-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"%:%:\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"%:%:\""))))
Theorem:
(defthm cst-comment-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "block-comment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block-comment"))))
Theorem:
(defthm cst-comment-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-comment") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-comment"))))
Theorem:
(defthm cst-rest-of-block-comment-after-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-white-space-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "space") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "space"))))
Theorem:
(defthm cst-white-space-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "horizontal-tab") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "horizontal-tab"))))
Theorem:
(defthm cst-white-space-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "vertical-tab") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "vertical-tab"))))
Theorem:
(defthm cst-white-space-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "form-feed") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "form-feed"))))
Theorem:
(defthm cst-white-space-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "new-line"))))
Theorem:
(defthm cst-lexeme-conc1-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-lexeme-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-lexeme-conc3-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-primary-expression-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-postfix-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "primary-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "primary-expression"))))
Theorem:
(defthm cst-argument-expression-list-conc1-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-unary-expression-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-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-unary-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-unary-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-unary-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-unary-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-unary-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-cast-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-multiplicative-expression-conc1-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-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-logical-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-logical-or-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "logical-and-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "logical-and-expression"))))
Theorem:
(defthm cst-conditional-expression-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "logical-or-expression") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "logical-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-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-expression-conc-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-constant-expression-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-init-declarator-list-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "init-declarator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "init-declarator"))))
Theorem:
(defthm cst-init-declarator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "declarator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "declarator"))))
Theorem:
(defthm cst-storage-class-specifier-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"extern\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"extern\""))))
Theorem:
(defthm cst-type-specifier-conc1-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-type-specifier-conc2-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-type-specifier-conc3-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-type-specifier-conc4-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-type-specifier-conc5-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-type-specifier-conc6-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-type-specifier-conc7-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-type-specifier-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"signed\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"signed\""))))
Theorem:
(defthm cst-type-specifier-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"unsigned\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"unsigned\""))))
Theorem:
(defthm cst-type-specifier-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"_Bool\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Bool\""))))
Theorem:
(defthm cst-type-specifier-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "struct-or-union-specifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "struct-or-union-specifier"))))
Theorem:
(defthm cst-type-specifier-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "enum-specifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enum-specifier"))))
Theorem:
(defthm cst-type-specifier-conc13-rep-matching (implies (cst-list-rep-matchp abnf::csts "typedef-name") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "typedef-name"))))
Theorem:
(defthm cst-struct-or-union-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"struct\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"struct\""))))
Theorem:
(defthm cst-struct-or-union-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"union\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"union\""))))
Theorem:
(defthm cst-struct-declaration-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "struct-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "struct-declaration"))))
Theorem:
(defthm cst-struct-declarator-list-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "struct-declarator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "struct-declarator"))))
Theorem:
(defthm cst-struct-declarator-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "declarator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "declarator"))))
Theorem:
(defthm cst-direct-declarator-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-pointer-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-parameter-type-list-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "parameter-list") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "parameter-list"))))
Theorem:
(defthm cst-parameter-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "parameter-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "parameter-declaration"))))
Theorem:
(defthm cst-abstract-declarator-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "pointer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "pointer"))))
Theorem:
(defthm cst-typedef-name-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-initializer-conc1-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-initializer-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "initializer") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "initializer"))))
Theorem:
(defthm cst-statement-conc1-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-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "compound-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "compound-statement"))))
Theorem:
(defthm cst-statement-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-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "selection-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "selection-statement"))))
Theorem:
(defthm cst-statement-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "iteration-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "iteration-statement"))))
Theorem:
(defthm cst-statement-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "jump-statement") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "jump-statement"))))
Theorem:
(defthm cst-block-item-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "block-item") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "block-item"))))
Theorem:
(defthm cst-block-item-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "declaration"))))
Theorem:
(defthm cst-block-item-conc2-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-translation-unit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "external-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "external-declaration"))))
Theorem:
(defthm cst-external-declaration-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "function-definition") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "function-definition"))))
Theorem:
(defthm cst-external-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "declaration"))))
Theorem:
(defthm cst-declaration-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "declaration"))))
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) "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) "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) "constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "constant"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "punctuator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "punctuator"))))))
Theorem:
(defthm cst-constant-conc-equivs (implies (cst-matchp abnf::cst "constant") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integer-constant"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enumeration-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enumeration-constant"))))))
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) "block-comment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block-comment"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "line-comment") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "line-comment"))))))
Theorem:
(defthm cst-white-space-conc-equivs (implies (cst-matchp abnf::cst "white-space") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "horizontal-tab") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "horizontal-tab"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "vertical-tab") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "vertical-tab"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "form-feed") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "form-feed"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "new-line"))))))
Theorem:
(defthm cst-lexeme-conc-equivs (implies (cst-matchp abnf::cst "lexeme") (and (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"))) (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) "white-space") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "white-space"))))))
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) "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) "compound-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "compound-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) "selection-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "selection-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "iteration-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "iteration-statement"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "jump-statement") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "jump-statement"))))))
Theorem:
(defthm cst-block-item-conc-equivs (implies (cst-matchp abnf::cst "block-item") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "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-external-declaration-conc-equivs (implies (cst-matchp abnf::cst "external-declaration") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "function-definition") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "function-definition"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "declaration"))))))
Function:
(defun cst-token-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "token"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "keyword")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "identifier")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "constant")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "punctuator")) 4) (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))) :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) "keyword"))))
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) "identifier"))))
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) "constant"))))
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) "punctuator"))))
Function:
(defun cst-constant-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "integer-constant")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enumeration-constant")) 2) (t (prog2$ (impossible) 1))))
Theorem:
(defthm posp-of-cst-constant-conc? (b* ((number (cst-constant-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc?-possibilities (b* ((number (cst-constant-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-constant-conc? abnf::cst)))))
Theorem:
(defthm cst-constant-conc?-of-tree-fix-cst (equal (cst-constant-conc? (abnf::tree-fix abnf::cst)) (cst-constant-conc? abnf::cst)))
Theorem:
(defthm cst-constant-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc? abnf::cst) (cst-constant-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-constant-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "constant") (iff (equal (cst-constant-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "integer-constant"))))
Theorem:
(defthm cst-constant-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "constant") (iff (equal (cst-constant-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enumeration-constant"))))
Function:
(defun cst-comment-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "comment"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "block-comment")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "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) "block-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) "line-comment"))))
Function:
(defun cst-white-space-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "white-space"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "horizontal-tab")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "vertical-tab")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "form-feed")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "new-line")) 5) (t (prog2$ (impossible) 1))))
Theorem:
(defthm posp-of-cst-white-space-conc? (b* ((number (cst-white-space-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc?-possibilities (b* ((number (cst-white-space-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-white-space-conc? abnf::cst)))))
Theorem:
(defthm cst-white-space-conc?-of-tree-fix-cst (equal (cst-white-space-conc? (abnf::tree-fix abnf::cst)) (cst-white-space-conc? abnf::cst)))
Theorem:
(defthm cst-white-space-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc? abnf::cst) (cst-white-space-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-white-space-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "white-space") (iff (equal (cst-white-space-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-white-space-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "white-space") (iff (equal (cst-white-space-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "horizontal-tab"))))
Theorem:
(defthm cst-white-space-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "white-space") (iff (equal (cst-white-space-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "vertical-tab"))))
Theorem:
(defthm cst-white-space-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "white-space") (iff (equal (cst-white-space-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "form-feed"))))
Theorem:
(defthm cst-white-space-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "white-space") (iff (equal (cst-white-space-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "new-line"))))
Function:
(defun cst-lexeme-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lexeme"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "token")) 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 "white-space")) 3) (t (prog2$ (impossible) 1))))
Theorem:
(defthm posp-of-cst-lexeme-conc? (b* ((number (cst-lexeme-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc?-possibilities (b* ((number (cst-lexeme-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-lexeme-conc? abnf::cst)))))
Theorem:
(defthm cst-lexeme-conc?-of-tree-fix-cst (equal (cst-lexeme-conc? (abnf::tree-fix abnf::cst)) (cst-lexeme-conc? abnf::cst)))
Theorem:
(defthm cst-lexeme-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc? abnf::cst) (cst-lexeme-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-lexeme-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "lexeme") (iff (equal (cst-lexeme-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "token"))))
Theorem:
(defthm cst-lexeme-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "lexeme") (iff (equal (cst-lexeme-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "comment"))))
Theorem:
(defthm cst-lexeme-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "lexeme") (iff (equal (cst-lexeme-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "white-space"))))
Function:
(defun cst-statement-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "statement"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "labeled-statement")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "compound-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 "selection-statement")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "iteration-statement")) 5) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "jump-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) "labeled-statement"))))
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) "compound-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) "expression-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) "selection-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) "iteration-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) "jump-statement"))))
Function:
(defun cst-block-item-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "block-item"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "declaration")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "statement")) 2) (t (prog2$ (impossible) 1))))
Theorem:
(defthm posp-of-cst-block-item-conc? (b* ((number (cst-block-item-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc?-possibilities (b* ((number (cst-block-item-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-block-item-conc? abnf::cst)))))
Theorem:
(defthm cst-block-item-conc?-of-tree-fix-cst (equal (cst-block-item-conc? (abnf::tree-fix abnf::cst)) (cst-block-item-conc? abnf::cst)))
Theorem:
(defthm cst-block-item-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc? abnf::cst) (cst-block-item-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-block-item-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "block-item") (iff (equal (cst-block-item-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration"))))
Theorem:
(defthm cst-block-item-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "block-item") (iff (equal (cst-block-item-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "statement"))))
Function:
(defun cst-external-declaration-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "external-declaration"))) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "function-definition")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "declaration")) 2) (t (prog2$ (impossible) 1))))
Theorem:
(defthm posp-of-cst-external-declaration-conc? (b* ((number (cst-external-declaration-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc?-possibilities (b* ((number (cst-external-declaration-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-external-declaration-conc? abnf::cst)))))
Theorem:
(defthm cst-external-declaration-conc?-of-tree-fix-cst (equal (cst-external-declaration-conc? (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc? abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc? abnf::cst) (cst-external-declaration-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-external-declaration-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "external-declaration") (iff (equal (cst-external-declaration-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "function-definition"))))
Theorem:
(defthm cst-external-declaration-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "external-declaration") (iff (equal (cst-external-declaration-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "declaration"))))
Function:
(defun cst-horizontal-tab-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-horizontal-tab-conc (b* ((abnf::cstss (cst-horizontal-tab-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-match (implies (cst-matchp abnf::cst "horizontal-tab") (b* ((abnf::cstss (cst-horizontal-tab-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-of-tree-fix-cst (equal (cst-horizontal-tab-conc (abnf::tree-fix abnf::cst)) (cst-horizontal-tab-conc abnf::cst)))
Theorem:
(defthm cst-horizontal-tab-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-horizontal-tab-conc abnf::cst) (cst-horizontal-tab-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-line-feed-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "line-feed"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-line-feed-conc (b* ((abnf::cstss (cst-line-feed-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-match (implies (cst-matchp abnf::cst "line-feed") (b* ((abnf::cstss (cst-line-feed-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-of-tree-fix-cst (equal (cst-line-feed-conc (abnf::tree-fix abnf::cst)) (cst-line-feed-conc abnf::cst)))
Theorem:
(defthm cst-line-feed-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-line-feed-conc abnf::cst) (cst-line-feed-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-vertical-tab-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-vertical-tab-conc (b* ((abnf::cstss (cst-vertical-tab-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-match (implies (cst-matchp abnf::cst "vertical-tab") (b* ((abnf::cstss (cst-vertical-tab-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%xB"))) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-of-tree-fix-cst (equal (cst-vertical-tab-conc (abnf::tree-fix abnf::cst)) (cst-vertical-tab-conc abnf::cst)))
Theorem:
(defthm cst-vertical-tab-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-vertical-tab-conc abnf::cst) (cst-vertical-tab-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-form-feed-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "form-feed"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-form-feed-conc (b* ((abnf::cstss (cst-form-feed-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-match (implies (cst-matchp abnf::cst "form-feed") (b* ((abnf::cstss (cst-form-feed-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%xC"))) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-of-tree-fix-cst (equal (cst-form-feed-conc (abnf::tree-fix abnf::cst)) (cst-form-feed-conc abnf::cst)))
Theorem:
(defthm cst-form-feed-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-form-feed-conc abnf::cst) (cst-form-feed-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-carriage-return-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-carriage-return-conc (b* ((abnf::cstss (cst-carriage-return-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-match (implies (cst-matchp abnf::cst "carriage-return") (b* ((abnf::cstss (cst-carriage-return-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-of-tree-fix-cst (equal (cst-carriage-return-conc (abnf::tree-fix abnf::cst)) (cst-carriage-return-conc abnf::cst)))
Theorem:
(defthm cst-carriage-return-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-carriage-return-conc abnf::cst) (cst-carriage-return-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-space-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-space-conc (b* ((abnf::cstss (cst-space-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-match (implies (cst-matchp abnf::cst "space") (b* ((abnf::cstss (cst-space-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-of-tree-fix-cst (equal (cst-space-conc (abnf::tree-fix abnf::cst)) (cst-space-conc abnf::cst)))
Theorem:
(defthm cst-space-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-space-conc abnf::cst) (cst-space-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-double-quote-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "double-quote"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-double-quote-conc (b* ((abnf::cstss (cst-double-quote-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-match (implies (cst-matchp abnf::cst "double-quote") (b* ((abnf::cstss (cst-double-quote-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-of-tree-fix-cst (equal (cst-double-quote-conc (abnf::tree-fix abnf::cst)) (cst-double-quote-conc abnf::cst)))
Theorem:
(defthm cst-double-quote-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-double-quote-conc abnf::cst) (cst-double-quote-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-character-conc (b* ((abnf::cstss (cst-character-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-match (implies (cst-matchp abnf::cst "character") (b* ((abnf::cstss (cst-character-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x0-7F"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-of-tree-fix-cst (equal (cst-character-conc (abnf::tree-fix abnf::cst)) (cst-character-conc abnf::cst)))
Theorem:
(defthm cst-character-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc abnf::cst) (cst-character-conc 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)))) (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 "keyword"))) :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)))) (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 "identifier"))) :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)))) (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 "constant"))) :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)))) (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 "punctuator"))) :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-identifier-nondigit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-identifier-nondigit-conc (b* ((abnf::cstss (cst-identifier-nondigit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-match (implies (cst-matchp abnf::cst "identifier-nondigit") (b* ((abnf::cstss (cst-identifier-nondigit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "nondigit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-of-tree-fix-cst (equal (cst-identifier-nondigit-conc (abnf::tree-fix abnf::cst)) (cst-identifier-nondigit-conc abnf::cst)))
Theorem:
(defthm cst-identifier-nondigit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-nondigit-conc abnf::cst) (cst-identifier-nondigit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-constant-conc1 (b* ((abnf::cstss (cst-constant-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-constant-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "integer-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-of-tree-fix-cst (equal (cst-constant-conc1 (abnf::tree-fix abnf::cst)) (cst-constant-conc1 abnf::cst)))
Theorem:
(defthm cst-constant-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc1 abnf::cst) (cst-constant-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-constant-conc2 (b* ((abnf::cstss (cst-constant-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-constant-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-of-tree-fix-cst (equal (cst-constant-conc2 (abnf::tree-fix abnf::cst)) (cst-constant-conc2 abnf::cst)))
Theorem:
(defthm cst-constant-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc2 abnf::cst) (cst-constant-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hexadecimal-prefix-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-hexadecimal-prefix-conc (b* ((abnf::cstss (cst-hexadecimal-prefix-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-match (implies (cst-matchp abnf::cst "hexadecimal-prefix") (b* ((abnf::cstss (cst-hexadecimal-prefix-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%i\"0x\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-of-tree-fix-cst (equal (cst-hexadecimal-prefix-conc (abnf::tree-fix abnf::cst)) (cst-hexadecimal-prefix-conc abnf::cst)))
Theorem:
(defthm cst-hexadecimal-prefix-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hexadecimal-prefix-conc abnf::cst) (cst-hexadecimal-prefix-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unsigned-suffix-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-unsigned-suffix-conc (b* ((abnf::cstss (cst-unsigned-suffix-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-match (implies (cst-matchp abnf::cst "unsigned-suffix") (b* ((abnf::cstss (cst-unsigned-suffix-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%i\"u\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-of-tree-fix-cst (equal (cst-unsigned-suffix-conc (abnf::tree-fix abnf::cst)) (cst-unsigned-suffix-conc abnf::cst)))
Theorem:
(defthm cst-unsigned-suffix-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unsigned-suffix-conc abnf::cst) (cst-unsigned-suffix-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-long-suffix-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "long-suffix"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-long-suffix-conc (b* ((abnf::cstss (cst-long-suffix-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-match (implies (cst-matchp abnf::cst "long-suffix") (b* ((abnf::cstss (cst-long-suffix-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%i\"l\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-of-tree-fix-cst (equal (cst-long-suffix-conc (abnf::tree-fix abnf::cst)) (cst-long-suffix-conc abnf::cst)))
Theorem:
(defthm cst-long-suffix-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-long-suffix-conc abnf::cst) (cst-long-suffix-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enumeration-constant-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enumeration-constant"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-enumeration-constant-conc (b* ((abnf::cstss (cst-enumeration-constant-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-match (implies (cst-matchp abnf::cst "enumeration-constant") (b* ((abnf::cstss (cst-enumeration-constant-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-of-tree-fix-cst (equal (cst-enumeration-constant-conc (abnf::tree-fix abnf::cst)) (cst-enumeration-constant-conc abnf::cst)))
Theorem:
(defthm cst-enumeration-constant-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enumeration-constant-conc abnf::cst) (cst-enumeration-constant-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-new-line-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "new-line"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-new-line-conc (b* ((abnf::cstss (cst-new-line-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-new-line-conc-match (implies (cst-matchp abnf::cst "new-line") (b* ((abnf::cstss (cst-new-line-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ carriage-return ] line-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-new-line-conc-of-tree-fix-cst (equal (cst-new-line-conc (abnf::tree-fix abnf::cst)) (cst-new-line-conc abnf::cst)))
Theorem:
(defthm cst-new-line-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-new-line-conc abnf::cst) (cst-new-line-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)))) (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 "block-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)))) (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 "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-block-comment-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "block-comment"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-block-comment-conc (b* ((abnf::cstss (cst-block-comment-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-comment-conc-match (implies (cst-matchp abnf::cst "block-comment") (b* ((abnf::cstss (cst-block-comment-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"/*\" rest-of-block-comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-comment-conc-of-tree-fix-cst (equal (cst-block-comment-conc (abnf::tree-fix abnf::cst)) (cst-block-comment-conc abnf::cst)))
Theorem:
(defthm cst-block-comment-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-comment-conc abnf::cst) (cst-block-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-line-comment-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "line-comment"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-line-comment-conc (b* ((abnf::cstss (cst-line-comment-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-line-comment-conc-match (implies (cst-matchp abnf::cst "line-comment") (b* ((abnf::cstss (cst-line-comment-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"//\" *not-line-feed-or-carriage-return"))) :rule-classes :rewrite)
Theorem:
(defthm cst-line-comment-conc-of-tree-fix-cst (equal (cst-line-comment-conc (abnf::tree-fix abnf::cst)) (cst-line-comment-conc abnf::cst)))
Theorem:
(defthm cst-line-comment-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-line-comment-conc abnf::cst) (cst-line-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-white-space-conc1 (b* ((abnf::cstss (cst-white-space-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-white-space-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-of-tree-fix-cst (equal (cst-white-space-conc1 (abnf::tree-fix abnf::cst)) (cst-white-space-conc1 abnf::cst)))
Theorem:
(defthm cst-white-space-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc1 abnf::cst) (cst-white-space-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-white-space-conc2 (b* ((abnf::cstss (cst-white-space-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-white-space-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-of-tree-fix-cst (equal (cst-white-space-conc2 (abnf::tree-fix abnf::cst)) (cst-white-space-conc2 abnf::cst)))
Theorem:
(defthm cst-white-space-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc2 abnf::cst) (cst-white-space-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-white-space-conc3 (b* ((abnf::cstss (cst-white-space-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-white-space-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-of-tree-fix-cst (equal (cst-white-space-conc3 (abnf::tree-fix abnf::cst)) (cst-white-space-conc3 abnf::cst)))
Theorem:
(defthm cst-white-space-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc3 abnf::cst) (cst-white-space-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-white-space-conc4 (b* ((abnf::cstss (cst-white-space-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-white-space-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-of-tree-fix-cst (equal (cst-white-space-conc4 (abnf::tree-fix abnf::cst)) (cst-white-space-conc4 abnf::cst)))
Theorem:
(defthm cst-white-space-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc4 abnf::cst) (cst-white-space-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-white-space-conc5 (b* ((abnf::cstss (cst-white-space-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-white-space-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-of-tree-fix-cst (equal (cst-white-space-conc5 (abnf::tree-fix abnf::cst)) (cst-white-space-conc5 abnf::cst)))
Theorem:
(defthm cst-white-space-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc5 abnf::cst) (cst-white-space-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-lexeme-conc1 (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-of-tree-fix-cst (equal (cst-lexeme-conc1 (abnf::tree-fix abnf::cst)) (cst-lexeme-conc1 abnf::cst)))
Theorem:
(defthm cst-lexeme-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc1 abnf::cst) (cst-lexeme-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-lexeme-conc2 (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-of-tree-fix-cst (equal (cst-lexeme-conc2 (abnf::tree-fix abnf::cst)) (cst-lexeme-conc2 abnf::cst)))
Theorem:
(defthm cst-lexeme-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc2 abnf::cst) (cst-lexeme-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-lexeme-conc3 (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-of-tree-fix-cst (equal (cst-lexeme-conc3 (abnf::tree-fix abnf::cst)) (cst-lexeme-conc3 abnf::cst)))
Theorem:
(defthm cst-lexeme-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc3 abnf::cst) (cst-lexeme-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "expression"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-expression-conc (b* ((abnf::cstss (cst-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc-match (implies (cst-matchp abnf::cst "expression") (b* ((abnf::cstss (cst-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "assignment-expression"))) :rule-classes :rewrite)
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)
Function:
(defun cst-constant-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (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 "conditional-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-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "declaration"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-declaration-conc (b* ((abnf::cstss (cst-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-declaration-conc-match (implies (cst-matchp abnf::cst "declaration") (b* ((abnf::cstss (cst-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers [ init-declarator-list ] \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-declaration-conc-of-tree-fix-cst (equal (cst-declaration-conc (abnf::tree-fix abnf::cst)) (cst-declaration-conc abnf::cst)))
Theorem:
(defthm cst-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-declaration-conc abnf::cst) (cst-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-init-declarator-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "init-declarator-list"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-init-declarator-list-conc (b* ((abnf::cstss (cst-init-declarator-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-match (implies (cst-matchp abnf::cst "init-declarator-list") (b* ((abnf::cstss (cst-init-declarator-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "init-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-of-tree-fix-cst (equal (cst-init-declarator-list-conc (abnf::tree-fix abnf::cst)) (cst-init-declarator-list-conc abnf::cst)))
Theorem:
(defthm cst-init-declarator-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-init-declarator-list-conc abnf::cst) (cst-init-declarator-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-storage-class-specifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "storage-class-specifier"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-storage-class-specifier-conc (b* ((abnf::cstss (cst-storage-class-specifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-match (implies (cst-matchp abnf::cst "storage-class-specifier") (b* ((abnf::cstss (cst-storage-class-specifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"extern\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-of-tree-fix-cst (equal (cst-storage-class-specifier-conc (abnf::tree-fix abnf::cst)) (cst-storage-class-specifier-conc abnf::cst)))
Theorem:
(defthm cst-storage-class-specifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-storage-class-specifier-conc abnf::cst) (cst-storage-class-specifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declaration"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-struct-declaration-conc (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declaration-conc-match (implies (cst-matchp abnf::cst "struct-declaration") (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "specifier-qualifier-list struct-declarator-list \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declaration-conc-of-tree-fix-cst (equal (cst-struct-declaration-conc (abnf::tree-fix abnf::cst)) (cst-struct-declaration-conc abnf::cst)))
Theorem:
(defthm cst-struct-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declaration-conc abnf::cst) (cst-struct-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-specifier-qualifier-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "specifier-qualifier-list"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-specifier-qualifier-list-conc (b* ((abnf::cstss (cst-specifier-qualifier-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-specifier-qualifier-list-conc-match (implies (cst-matchp abnf::cst "specifier-qualifier-list") (b* ((abnf::cstss (cst-specifier-qualifier-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "type-specifier [ specifier-qualifier-list ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-specifier-qualifier-list-conc-of-tree-fix-cst (equal (cst-specifier-qualifier-list-conc (abnf::tree-fix abnf::cst)) (cst-specifier-qualifier-list-conc abnf::cst)))
Theorem:
(defthm cst-specifier-qualifier-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-specifier-qualifier-list-conc abnf::cst) (cst-specifier-qualifier-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator-list"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-struct-declarator-list-conc (b* ((abnf::cstss (cst-struct-declarator-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-match (implies (cst-matchp abnf::cst "struct-declarator-list") (b* ((abnf::cstss (cst-struct-declarator-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "struct-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-of-tree-fix-cst (equal (cst-struct-declarator-list-conc (abnf::tree-fix abnf::cst)) (cst-struct-declarator-list-conc abnf::cst)))
Theorem:
(defthm cst-struct-declarator-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-list-conc abnf::cst) (cst-struct-declarator-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-struct-declarator-conc (b* ((abnf::cstss (cst-struct-declarator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-match (implies (cst-matchp abnf::cst "struct-declarator") (b* ((abnf::cstss (cst-struct-declarator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-of-tree-fix-cst (equal (cst-struct-declarator-conc (abnf::tree-fix abnf::cst)) (cst-struct-declarator-conc abnf::cst)))
Theorem:
(defthm cst-struct-declarator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-conc abnf::cst) (cst-struct-declarator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enum-specifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enum-specifier"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-enum-specifier-conc (b* ((abnf::cstss (cst-enum-specifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-specifier-conc-match (implies (cst-matchp abnf::cst "enum-specifier") (b* ((abnf::cstss (cst-enum-specifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enum-specifier-conc-of-tree-fix-cst (equal (cst-enum-specifier-conc (abnf::tree-fix abnf::cst)) (cst-enum-specifier-conc abnf::cst)))
Theorem:
(defthm cst-enum-specifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enum-specifier-conc abnf::cst) (cst-enum-specifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-declarator-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "declarator"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-declarator-conc (b* ((abnf::cstss (cst-declarator-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-declarator-conc-match (implies (cst-matchp abnf::cst "declarator") (b* ((abnf::cstss (cst-declarator-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ pointer ] direct-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-declarator-conc-of-tree-fix-cst (equal (cst-declarator-conc (abnf::tree-fix abnf::cst)) (cst-declarator-conc abnf::cst)))
Theorem:
(defthm cst-declarator-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-declarator-conc abnf::cst) (cst-declarator-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-parameter-type-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "parameter-type-list"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-parameter-type-list-conc (b* ((abnf::cstss (cst-parameter-type-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-match (implies (cst-matchp abnf::cst "parameter-type-list") (b* ((abnf::cstss (cst-parameter-type-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "parameter-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-of-tree-fix-cst (equal (cst-parameter-type-list-conc (abnf::tree-fix abnf::cst)) (cst-parameter-type-list-conc abnf::cst)))
Theorem:
(defthm cst-parameter-type-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-parameter-type-list-conc abnf::cst) (cst-parameter-type-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-parameter-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "parameter-declaration"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-parameter-declaration-conc (b* ((abnf::cstss (cst-parameter-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-declaration-conc-match (implies (cst-matchp abnf::cst "parameter-declaration") (b* ((abnf::cstss (cst-parameter-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-declaration-conc-of-tree-fix-cst (equal (cst-parameter-declaration-conc (abnf::tree-fix abnf::cst)) (cst-parameter-declaration-conc abnf::cst)))
Theorem:
(defthm cst-parameter-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-parameter-declaration-conc abnf::cst) (cst-parameter-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-type-name-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-name"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-type-name-conc (b* ((abnf::cstss (cst-type-name-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-type-name-conc-match (implies (cst-matchp abnf::cst "type-name") (b* ((abnf::cstss (cst-type-name-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "specifier-qualifier-list [ abstract-declarator ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-type-name-conc-of-tree-fix-cst (equal (cst-type-name-conc (abnf::tree-fix abnf::cst)) (cst-type-name-conc abnf::cst)))
Theorem:
(defthm cst-type-name-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-type-name-conc abnf::cst) (cst-type-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-typedef-name-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "typedef-name"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-typedef-name-conc (b* ((abnf::cstss (cst-typedef-name-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-match (implies (cst-matchp abnf::cst "typedef-name") (b* ((abnf::cstss (cst-typedef-name-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-of-tree-fix-cst (equal (cst-typedef-name-conc (abnf::tree-fix abnf::cst)) (cst-typedef-name-conc abnf::cst)))
Theorem:
(defthm cst-typedef-name-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-typedef-name-conc abnf::cst) (cst-typedef-name-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)))) (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 "labeled-statement"))) :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)))) (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 "compound-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)))) (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 "expression-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)))) (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 "selection-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)))) (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 "iteration-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)))) (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 "jump-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-compound-statement-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "compound-statement"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-compound-statement-conc (b* ((abnf::cstss (cst-compound-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-compound-statement-conc-match (implies (cst-matchp abnf::cst "compound-statement") (b* ((abnf::cstss (cst-compound-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"{\" [ block-item-list ] \"}\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-compound-statement-conc-of-tree-fix-cst (equal (cst-compound-statement-conc (abnf::tree-fix abnf::cst)) (cst-compound-statement-conc abnf::cst)))
Theorem:
(defthm cst-compound-statement-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-compound-statement-conc abnf::cst) (cst-compound-statement-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-item-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-block-item-conc1 (b* ((abnf::cstss (cst-block-item-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-block-item-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-of-tree-fix-cst (equal (cst-block-item-conc1 (abnf::tree-fix abnf::cst)) (cst-block-item-conc1 abnf::cst)))
Theorem:
(defthm cst-block-item-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc1 abnf::cst) (cst-block-item-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-item-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-block-item-conc2 (b* ((abnf::cstss (cst-block-item-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-block-item-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-of-tree-fix-cst (equal (cst-block-item-conc2 (abnf::tree-fix abnf::cst)) (cst-block-item-conc2 abnf::cst)))
Theorem:
(defthm cst-block-item-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc2 abnf::cst) (cst-block-item-conc2 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"))) (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 "[ 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-external-declaration-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-external-declaration-conc1 (b* ((abnf::cstss (cst-external-declaration-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-external-declaration-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "function-definition"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-of-tree-fix-cst (equal (cst-external-declaration-conc1 (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc1 abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc1 abnf::cst) (cst-external-declaration-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-external-declaration-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-external-declaration-conc2 (b* ((abnf::cstss (cst-external-declaration-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-external-declaration-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-of-tree-fix-cst (equal (cst-external-declaration-conc2 (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc2 abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc2 abnf::cst) (cst-external-declaration-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-function-definition-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "function-definition"))) (abnf::tree-nonleaf->branches abnf::cst))
Theorem:
(defthm tree-list-listp-of-cst-function-definition-conc (b* ((abnf::cstss (cst-function-definition-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-function-definition-conc-match (implies (cst-matchp abnf::cst "function-definition") (b* ((abnf::cstss (cst-function-definition-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers declarator compound-statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-function-definition-conc-of-tree-fix-cst (equal (cst-function-definition-conc (abnf::tree-fix abnf::cst)) (cst-function-definition-conc abnf::cst)))
Theorem:
(defthm cst-function-definition-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-function-definition-conc abnf::cst) (cst-function-definition-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-horizontal-tab-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (abnf::tree-list-fix (nth 0 (cst-horizontal-tab-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-horizontal-tab-conc-rep (b* ((abnf::csts (cst-horizontal-tab-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-rep-match (implies (cst-matchp abnf::cst "horizontal-tab") (b* ((abnf::csts (cst-horizontal-tab-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-rep-of-tree-fix-cst (equal (cst-horizontal-tab-conc-rep (abnf::tree-fix abnf::cst)) (cst-horizontal-tab-conc-rep abnf::cst)))
Theorem:
(defthm cst-horizontal-tab-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-horizontal-tab-conc-rep abnf::cst) (cst-horizontal-tab-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-line-feed-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "line-feed"))) (abnf::tree-list-fix (nth 0 (cst-line-feed-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-line-feed-conc-rep (b* ((abnf::csts (cst-line-feed-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-rep-match (implies (cst-matchp abnf::cst "line-feed") (b* ((abnf::csts (cst-line-feed-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-rep-of-tree-fix-cst (equal (cst-line-feed-conc-rep (abnf::tree-fix abnf::cst)) (cst-line-feed-conc-rep abnf::cst)))
Theorem:
(defthm cst-line-feed-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-line-feed-conc-rep abnf::cst) (cst-line-feed-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-vertical-tab-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (abnf::tree-list-fix (nth 0 (cst-vertical-tab-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-vertical-tab-conc-rep (b* ((abnf::csts (cst-vertical-tab-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-rep-match (implies (cst-matchp abnf::cst "vertical-tab") (b* ((abnf::csts (cst-vertical-tab-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%xB"))) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-rep-of-tree-fix-cst (equal (cst-vertical-tab-conc-rep (abnf::tree-fix abnf::cst)) (cst-vertical-tab-conc-rep abnf::cst)))
Theorem:
(defthm cst-vertical-tab-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-vertical-tab-conc-rep abnf::cst) (cst-vertical-tab-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-form-feed-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "form-feed"))) (abnf::tree-list-fix (nth 0 (cst-form-feed-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-form-feed-conc-rep (b* ((abnf::csts (cst-form-feed-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-rep-match (implies (cst-matchp abnf::cst "form-feed") (b* ((abnf::csts (cst-form-feed-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%xC"))) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-rep-of-tree-fix-cst (equal (cst-form-feed-conc-rep (abnf::tree-fix abnf::cst)) (cst-form-feed-conc-rep abnf::cst)))
Theorem:
(defthm cst-form-feed-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-form-feed-conc-rep abnf::cst) (cst-form-feed-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-carriage-return-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (abnf::tree-list-fix (nth 0 (cst-carriage-return-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-carriage-return-conc-rep (b* ((abnf::csts (cst-carriage-return-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-rep-match (implies (cst-matchp abnf::cst "carriage-return") (b* ((abnf::csts (cst-carriage-return-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-rep-of-tree-fix-cst (equal (cst-carriage-return-conc-rep (abnf::tree-fix abnf::cst)) (cst-carriage-return-conc-rep abnf::cst)))
Theorem:
(defthm cst-carriage-return-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-carriage-return-conc-rep abnf::cst) (cst-carriage-return-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-space-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (abnf::tree-list-fix (nth 0 (cst-space-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-space-conc-rep (b* ((abnf::csts (cst-space-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-rep-match (implies (cst-matchp abnf::cst "space") (b* ((abnf::csts (cst-space-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-rep-of-tree-fix-cst (equal (cst-space-conc-rep (abnf::tree-fix abnf::cst)) (cst-space-conc-rep abnf::cst)))
Theorem:
(defthm cst-space-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-space-conc-rep abnf::cst) (cst-space-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-double-quote-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "double-quote"))) (abnf::tree-list-fix (nth 0 (cst-double-quote-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-double-quote-conc-rep (b* ((abnf::csts (cst-double-quote-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-rep-match (implies (cst-matchp abnf::cst "double-quote") (b* ((abnf::csts (cst-double-quote-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-rep-of-tree-fix-cst (equal (cst-double-quote-conc-rep (abnf::tree-fix abnf::cst)) (cst-double-quote-conc-rep abnf::cst)))
Theorem:
(defthm cst-double-quote-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-double-quote-conc-rep abnf::cst) (cst-double-quote-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character"))) (abnf::tree-list-fix (nth 0 (cst-character-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-character-conc-rep (b* ((abnf::csts (cst-character-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-rep-match (implies (cst-matchp abnf::cst "character") (b* ((abnf::csts (cst-character-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x0-7F"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-rep-of-tree-fix-cst (equal (cst-character-conc-rep (abnf::tree-fix abnf::cst)) (cst-character-conc-rep abnf::cst)))
Theorem:
(defthm cst-character-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc-rep abnf::cst) (cst-character-conc-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)))) (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 "keyword"))) :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)))) (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 "identifier"))) :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)))) (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 "constant"))) :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)))) (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 "punctuator"))) :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-identifier-nondigit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (abnf::tree-list-fix (nth 0 (cst-identifier-nondigit-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-identifier-nondigit-conc-rep (b* ((abnf::csts (cst-identifier-nondigit-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-rep-match (implies (cst-matchp abnf::cst "identifier-nondigit") (b* ((abnf::csts (cst-identifier-nondigit-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "nondigit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-rep-of-tree-fix-cst (equal (cst-identifier-nondigit-conc-rep (abnf::tree-fix abnf::cst)) (cst-identifier-nondigit-conc-rep abnf::cst)))
Theorem:
(defthm cst-identifier-nondigit-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-nondigit-conc-rep abnf::cst) (cst-identifier-nondigit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)))) (abnf::tree-list-fix (nth 0 (cst-constant-conc1 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-constant-conc1-rep (b* ((abnf::csts (cst-constant-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-rep-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-constant-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "integer-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-rep-of-tree-fix-cst (equal (cst-constant-conc1-rep (abnf::tree-fix abnf::cst)) (cst-constant-conc1-rep abnf::cst)))
Theorem:
(defthm cst-constant-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc1-rep abnf::cst) (cst-constant-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)))) (abnf::tree-list-fix (nth 0 (cst-constant-conc2 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-constant-conc2-rep (b* ((abnf::csts (cst-constant-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-rep-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-constant-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-rep-of-tree-fix-cst (equal (cst-constant-conc2-rep (abnf::tree-fix abnf::cst)) (cst-constant-conc2-rep abnf::cst)))
Theorem:
(defthm cst-constant-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc2-rep abnf::cst) (cst-constant-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hexadecimal-prefix-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix"))) (abnf::tree-list-fix (nth 0 (cst-hexadecimal-prefix-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-hexadecimal-prefix-conc-rep (b* ((abnf::csts (cst-hexadecimal-prefix-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-match (implies (cst-matchp abnf::cst "hexadecimal-prefix") (b* ((abnf::csts (cst-hexadecimal-prefix-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%i\"0x\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-of-tree-fix-cst (equal (cst-hexadecimal-prefix-conc-rep (abnf::tree-fix abnf::cst)) (cst-hexadecimal-prefix-conc-rep abnf::cst)))
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hexadecimal-prefix-conc-rep abnf::cst) (cst-hexadecimal-prefix-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unsigned-suffix-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix"))) (abnf::tree-list-fix (nth 0 (cst-unsigned-suffix-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-unsigned-suffix-conc-rep (b* ((abnf::csts (cst-unsigned-suffix-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-rep-match (implies (cst-matchp abnf::cst "unsigned-suffix") (b* ((abnf::csts (cst-unsigned-suffix-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%i\"u\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-rep-of-tree-fix-cst (equal (cst-unsigned-suffix-conc-rep (abnf::tree-fix abnf::cst)) (cst-unsigned-suffix-conc-rep abnf::cst)))
Theorem:
(defthm cst-unsigned-suffix-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unsigned-suffix-conc-rep abnf::cst) (cst-unsigned-suffix-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-long-suffix-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "long-suffix"))) (abnf::tree-list-fix (nth 0 (cst-long-suffix-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-long-suffix-conc-rep (b* ((abnf::csts (cst-long-suffix-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-rep-match (implies (cst-matchp abnf::cst "long-suffix") (b* ((abnf::csts (cst-long-suffix-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%i\"l\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-rep-of-tree-fix-cst (equal (cst-long-suffix-conc-rep (abnf::tree-fix abnf::cst)) (cst-long-suffix-conc-rep abnf::cst)))
Theorem:
(defthm cst-long-suffix-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-long-suffix-conc-rep abnf::cst) (cst-long-suffix-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enumeration-constant-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enumeration-constant"))) (abnf::tree-list-fix (nth 0 (cst-enumeration-constant-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-enumeration-constant-conc-rep (b* ((abnf::csts (cst-enumeration-constant-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-rep-match (implies (cst-matchp abnf::cst "enumeration-constant") (b* ((abnf::csts (cst-enumeration-constant-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-rep-of-tree-fix-cst (equal (cst-enumeration-constant-conc-rep (abnf::tree-fix abnf::cst)) (cst-enumeration-constant-conc-rep abnf::cst)))
Theorem:
(defthm cst-enumeration-constant-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enumeration-constant-conc-rep abnf::cst) (cst-enumeration-constant-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)))) (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 "block-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)))) (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 "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-white-space-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)))) (abnf::tree-list-fix (nth 0 (cst-white-space-conc1 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-white-space-conc1-rep (b* ((abnf::csts (cst-white-space-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-rep-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-white-space-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-rep-of-tree-fix-cst (equal (cst-white-space-conc1-rep (abnf::tree-fix abnf::cst)) (cst-white-space-conc1-rep abnf::cst)))
Theorem:
(defthm cst-white-space-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc1-rep abnf::cst) (cst-white-space-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)))) (abnf::tree-list-fix (nth 0 (cst-white-space-conc2 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-white-space-conc2-rep (b* ((abnf::csts (cst-white-space-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-rep-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-white-space-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-rep-of-tree-fix-cst (equal (cst-white-space-conc2-rep (abnf::tree-fix abnf::cst)) (cst-white-space-conc2-rep abnf::cst)))
Theorem:
(defthm cst-white-space-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc2-rep abnf::cst) (cst-white-space-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)))) (abnf::tree-list-fix (nth 0 (cst-white-space-conc3 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-white-space-conc3-rep (b* ((abnf::csts (cst-white-space-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-rep-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-white-space-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-rep-of-tree-fix-cst (equal (cst-white-space-conc3-rep (abnf::tree-fix abnf::cst)) (cst-white-space-conc3-rep abnf::cst)))
Theorem:
(defthm cst-white-space-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc3-rep abnf::cst) (cst-white-space-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)))) (abnf::tree-list-fix (nth 0 (cst-white-space-conc4 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-white-space-conc4-rep (b* ((abnf::csts (cst-white-space-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-rep-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-white-space-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-rep-of-tree-fix-cst (equal (cst-white-space-conc4-rep (abnf::tree-fix abnf::cst)) (cst-white-space-conc4-rep abnf::cst)))
Theorem:
(defthm cst-white-space-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc4-rep abnf::cst) (cst-white-space-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)))) (abnf::tree-list-fix (nth 0 (cst-white-space-conc5 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-white-space-conc5-rep (b* ((abnf::csts (cst-white-space-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-rep-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-white-space-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-rep-of-tree-fix-cst (equal (cst-white-space-conc5-rep (abnf::tree-fix abnf::cst)) (cst-white-space-conc5-rep abnf::cst)))
Theorem:
(defthm cst-white-space-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc5-rep abnf::cst) (cst-white-space-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)))) (abnf::tree-list-fix (nth 0 (cst-lexeme-conc1 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-lexeme-conc1-rep (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-rep-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-rep-of-tree-fix-cst (equal (cst-lexeme-conc1-rep (abnf::tree-fix abnf::cst)) (cst-lexeme-conc1-rep abnf::cst)))
Theorem:
(defthm cst-lexeme-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc1-rep abnf::cst) (cst-lexeme-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)))) (abnf::tree-list-fix (nth 0 (cst-lexeme-conc2 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-lexeme-conc2-rep (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-rep-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-rep-of-tree-fix-cst (equal (cst-lexeme-conc2-rep (abnf::tree-fix abnf::cst)) (cst-lexeme-conc2-rep abnf::cst)))
Theorem:
(defthm cst-lexeme-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc2-rep abnf::cst) (cst-lexeme-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)))) (abnf::tree-list-fix (nth 0 (cst-lexeme-conc3 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-lexeme-conc3-rep (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-rep-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-rep-of-tree-fix-cst (equal (cst-lexeme-conc3-rep (abnf::tree-fix abnf::cst)) (cst-lexeme-conc3-rep abnf::cst)))
Theorem:
(defthm cst-lexeme-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc3-rep abnf::cst) (cst-lexeme-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "expression"))) (abnf::tree-list-fix (nth 0 (cst-expression-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-expression-conc-rep (b* ((abnf::csts (cst-expression-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc-rep-match (implies (cst-matchp abnf::cst "expression") (b* ((abnf::csts (cst-expression-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "assignment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc-rep-of-tree-fix-cst (equal (cst-expression-conc-rep (abnf::tree-fix abnf::cst)) (cst-expression-conc-rep abnf::cst)))
Theorem:
(defthm cst-expression-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc-rep abnf::cst) (cst-expression-conc-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"))) (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 "conditional-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-init-declarator-list-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "init-declarator-list"))) (abnf::tree-list-fix (nth 0 (cst-init-declarator-list-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-init-declarator-list-conc-rep (b* ((abnf::csts (cst-init-declarator-list-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-rep-match (implies (cst-matchp abnf::cst "init-declarator-list") (b* ((abnf::csts (cst-init-declarator-list-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "init-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-rep-of-tree-fix-cst (equal (cst-init-declarator-list-conc-rep (abnf::tree-fix abnf::cst)) (cst-init-declarator-list-conc-rep abnf::cst)))
Theorem:
(defthm cst-init-declarator-list-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-init-declarator-list-conc-rep abnf::cst) (cst-init-declarator-list-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-storage-class-specifier-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "storage-class-specifier"))) (abnf::tree-list-fix (nth 0 (cst-storage-class-specifier-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-storage-class-specifier-conc-rep (b* ((abnf::csts (cst-storage-class-specifier-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-rep-match (implies (cst-matchp abnf::cst "storage-class-specifier") (b* ((abnf::csts (cst-storage-class-specifier-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%s\"extern\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-rep-of-tree-fix-cst (equal (cst-storage-class-specifier-conc-rep (abnf::tree-fix abnf::cst)) (cst-storage-class-specifier-conc-rep abnf::cst)))
Theorem:
(defthm cst-storage-class-specifier-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-storage-class-specifier-conc-rep abnf::cst) (cst-storage-class-specifier-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-list-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator-list"))) (abnf::tree-list-fix (nth 0 (cst-struct-declarator-list-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-struct-declarator-list-conc-rep (b* ((abnf::csts (cst-struct-declarator-list-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-rep-match (implies (cst-matchp abnf::cst "struct-declarator-list") (b* ((abnf::csts (cst-struct-declarator-list-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "struct-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-rep-of-tree-fix-cst (equal (cst-struct-declarator-list-conc-rep (abnf::tree-fix abnf::cst)) (cst-struct-declarator-list-conc-rep abnf::cst)))
Theorem:
(defthm cst-struct-declarator-list-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-list-conc-rep abnf::cst) (cst-struct-declarator-list-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator"))) (abnf::tree-list-fix (nth 0 (cst-struct-declarator-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-struct-declarator-conc-rep (b* ((abnf::csts (cst-struct-declarator-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-rep-match (implies (cst-matchp abnf::cst "struct-declarator") (b* ((abnf::csts (cst-struct-declarator-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-rep-of-tree-fix-cst (equal (cst-struct-declarator-conc-rep (abnf::tree-fix abnf::cst)) (cst-struct-declarator-conc-rep abnf::cst)))
Theorem:
(defthm cst-struct-declarator-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-conc-rep abnf::cst) (cst-struct-declarator-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-parameter-type-list-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "parameter-type-list"))) (abnf::tree-list-fix (nth 0 (cst-parameter-type-list-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-parameter-type-list-conc-rep (b* ((abnf::csts (cst-parameter-type-list-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-rep-match (implies (cst-matchp abnf::cst "parameter-type-list") (b* ((abnf::csts (cst-parameter-type-list-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "parameter-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-rep-of-tree-fix-cst (equal (cst-parameter-type-list-conc-rep (abnf::tree-fix abnf::cst)) (cst-parameter-type-list-conc-rep abnf::cst)))
Theorem:
(defthm cst-parameter-type-list-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-parameter-type-list-conc-rep abnf::cst) (cst-parameter-type-list-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-typedef-name-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "typedef-name"))) (abnf::tree-list-fix (nth 0 (cst-typedef-name-conc abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-typedef-name-conc-rep (b* ((abnf::csts (cst-typedef-name-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-rep-match (implies (cst-matchp abnf::cst "typedef-name") (b* ((abnf::csts (cst-typedef-name-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-rep-of-tree-fix-cst (equal (cst-typedef-name-conc-rep (abnf::tree-fix abnf::cst)) (cst-typedef-name-conc-rep abnf::cst)))
Theorem:
(defthm cst-typedef-name-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-typedef-name-conc-rep abnf::cst) (cst-typedef-name-conc-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)))) (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 "labeled-statement"))) :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)))) (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 "compound-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)))) (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 "expression-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)))) (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 "selection-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)))) (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 "iteration-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)))) (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 "jump-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-block-item-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)))) (abnf::tree-list-fix (nth 0 (cst-block-item-conc1 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-block-item-conc1-rep (b* ((abnf::csts (cst-block-item-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-rep-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-block-item-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-rep-of-tree-fix-cst (equal (cst-block-item-conc1-rep (abnf::tree-fix abnf::cst)) (cst-block-item-conc1-rep abnf::cst)))
Theorem:
(defthm cst-block-item-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc1-rep abnf::cst) (cst-block-item-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-item-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)))) (abnf::tree-list-fix (nth 0 (cst-block-item-conc2 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-block-item-conc2-rep (b* ((abnf::csts (cst-block-item-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-rep-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-block-item-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-rep-of-tree-fix-cst (equal (cst-block-item-conc2-rep (abnf::tree-fix abnf::cst)) (cst-block-item-conc2-rep abnf::cst)))
Theorem:
(defthm cst-block-item-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc2-rep abnf::cst) (cst-block-item-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-external-declaration-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)))) (abnf::tree-list-fix (nth 0 (cst-external-declaration-conc1 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-external-declaration-conc1-rep (b* ((abnf::csts (cst-external-declaration-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-rep-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-external-declaration-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "function-definition"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-rep-of-tree-fix-cst (equal (cst-external-declaration-conc1-rep (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc1-rep abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc1-rep abnf::cst) (cst-external-declaration-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-external-declaration-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)))) (abnf::tree-list-fix (nth 0 (cst-external-declaration-conc2 abnf::cst))))
Theorem:
(defthm tree-listp-of-cst-external-declaration-conc2-rep (b* ((abnf::csts (cst-external-declaration-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-rep-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-external-declaration-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-rep-of-tree-fix-cst (equal (cst-external-declaration-conc2-rep (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc2-rep abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc2-rep abnf::cst) (cst-external-declaration-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-horizontal-tab-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (abnf::tree-fix (nth 0 (cst-horizontal-tab-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-horizontal-tab-conc-rep-elem (b* ((abnf::cst1 (cst-horizontal-tab-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-rep-elem-match (implies (cst-matchp abnf::cst "horizontal-tab") (b* ((abnf::cst1 (cst-horizontal-tab-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm cst-horizontal-tab-conc-rep-elem-of-tree-fix-cst (equal (cst-horizontal-tab-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-horizontal-tab-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-horizontal-tab-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-horizontal-tab-conc-rep-elem abnf::cst) (cst-horizontal-tab-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-line-feed-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "line-feed"))) (abnf::tree-fix (nth 0 (cst-line-feed-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-line-feed-conc-rep-elem (b* ((abnf::cst1 (cst-line-feed-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-rep-elem-match (implies (cst-matchp abnf::cst "line-feed") (b* ((abnf::cst1 (cst-line-feed-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm cst-line-feed-conc-rep-elem-of-tree-fix-cst (equal (cst-line-feed-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-line-feed-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-line-feed-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-line-feed-conc-rep-elem abnf::cst) (cst-line-feed-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-vertical-tab-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (abnf::tree-fix (nth 0 (cst-vertical-tab-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-vertical-tab-conc-rep-elem (b* ((abnf::cst1 (cst-vertical-tab-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-rep-elem-match (implies (cst-matchp abnf::cst "vertical-tab") (b* ((abnf::cst1 (cst-vertical-tab-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%xB"))) :rule-classes :rewrite)
Theorem:
(defthm cst-vertical-tab-conc-rep-elem-of-tree-fix-cst (equal (cst-vertical-tab-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-vertical-tab-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-vertical-tab-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-vertical-tab-conc-rep-elem abnf::cst) (cst-vertical-tab-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-form-feed-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "form-feed"))) (abnf::tree-fix (nth 0 (cst-form-feed-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-form-feed-conc-rep-elem (b* ((abnf::cst1 (cst-form-feed-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-rep-elem-match (implies (cst-matchp abnf::cst "form-feed") (b* ((abnf::cst1 (cst-form-feed-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%xC"))) :rule-classes :rewrite)
Theorem:
(defthm cst-form-feed-conc-rep-elem-of-tree-fix-cst (equal (cst-form-feed-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-form-feed-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-form-feed-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-form-feed-conc-rep-elem abnf::cst) (cst-form-feed-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-carriage-return-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (abnf::tree-fix (nth 0 (cst-carriage-return-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-carriage-return-conc-rep-elem (b* ((abnf::cst1 (cst-carriage-return-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-rep-elem-match (implies (cst-matchp abnf::cst "carriage-return") (b* ((abnf::cst1 (cst-carriage-return-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm cst-carriage-return-conc-rep-elem-of-tree-fix-cst (equal (cst-carriage-return-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-carriage-return-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-carriage-return-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-carriage-return-conc-rep-elem abnf::cst) (cst-carriage-return-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-space-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (abnf::tree-fix (nth 0 (cst-space-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-space-conc-rep-elem (b* ((abnf::cst1 (cst-space-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-rep-elem-match (implies (cst-matchp abnf::cst "space") (b* ((abnf::cst1 (cst-space-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm cst-space-conc-rep-elem-of-tree-fix-cst (equal (cst-space-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-space-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-space-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-space-conc-rep-elem abnf::cst) (cst-space-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-double-quote-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "double-quote"))) (abnf::tree-fix (nth 0 (cst-double-quote-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-double-quote-conc-rep-elem (b* ((abnf::cst1 (cst-double-quote-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-rep-elem-match (implies (cst-matchp abnf::cst "double-quote") (b* ((abnf::cst1 (cst-double-quote-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm cst-double-quote-conc-rep-elem-of-tree-fix-cst (equal (cst-double-quote-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-double-quote-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-double-quote-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-double-quote-conc-rep-elem abnf::cst) (cst-double-quote-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character"))) (abnf::tree-fix (nth 0 (cst-character-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-character-conc-rep-elem (b* ((abnf::cst1 (cst-character-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-rep-elem-match (implies (cst-matchp abnf::cst "character") (b* ((abnf::cst1 (cst-character-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x0-7F"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc-rep-elem-of-tree-fix-cst (equal (cst-character-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc-rep-elem abnf::cst) (cst-character-conc-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)))) (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 "keyword"))) :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)))) (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 "identifier"))) :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)))) (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 "constant"))) :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)))) (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 "punctuator"))) :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-identifier-nondigit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (abnf::tree-fix (nth 0 (cst-identifier-nondigit-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-identifier-nondigit-conc-rep-elem (b* ((abnf::cst1 (cst-identifier-nondigit-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-rep-elem-match (implies (cst-matchp abnf::cst "identifier-nondigit") (b* ((abnf::cst1 (cst-identifier-nondigit-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "nondigit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-identifier-nondigit-conc-rep-elem-of-tree-fix-cst (equal (cst-identifier-nondigit-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-identifier-nondigit-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-identifier-nondigit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-identifier-nondigit-conc-rep-elem abnf::cst) (cst-identifier-nondigit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)))) (abnf::tree-fix (nth 0 (cst-constant-conc1-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-constant-conc1-rep-elem (b* ((abnf::cst1 (cst-constant-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-constant-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "integer-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc1-rep-elem-of-tree-fix-cst (equal (cst-constant-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-constant-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-constant-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc1-rep-elem abnf::cst) (cst-constant-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)))) (abnf::tree-fix (nth 0 (cst-constant-conc2-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-constant-conc2-rep-elem (b* ((abnf::cst1 (cst-constant-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-constant-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc2-rep-elem-of-tree-fix-cst (equal (cst-constant-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-constant-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-constant-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc2-rep-elem abnf::cst) (cst-constant-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-hexadecimal-prefix-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix"))) (abnf::tree-fix (nth 0 (cst-hexadecimal-prefix-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-hexadecimal-prefix-conc-rep-elem (b* ((abnf::cst1 (cst-hexadecimal-prefix-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-elem-match (implies (cst-matchp abnf::cst "hexadecimal-prefix") (b* ((abnf::cst1 (cst-hexadecimal-prefix-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%i\"0x\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-elem-of-tree-fix-cst (equal (cst-hexadecimal-prefix-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-hexadecimal-prefix-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-hexadecimal-prefix-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hexadecimal-prefix-conc-rep-elem abnf::cst) (cst-hexadecimal-prefix-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-unsigned-suffix-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix"))) (abnf::tree-fix (nth 0 (cst-unsigned-suffix-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-unsigned-suffix-conc-rep-elem (b* ((abnf::cst1 (cst-unsigned-suffix-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-rep-elem-match (implies (cst-matchp abnf::cst "unsigned-suffix") (b* ((abnf::cst1 (cst-unsigned-suffix-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%i\"u\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-unsigned-suffix-conc-rep-elem-of-tree-fix-cst (equal (cst-unsigned-suffix-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-unsigned-suffix-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-unsigned-suffix-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-unsigned-suffix-conc-rep-elem abnf::cst) (cst-unsigned-suffix-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-long-suffix-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "long-suffix"))) (abnf::tree-fix (nth 0 (cst-long-suffix-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-long-suffix-conc-rep-elem (b* ((abnf::cst1 (cst-long-suffix-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-rep-elem-match (implies (cst-matchp abnf::cst "long-suffix") (b* ((abnf::cst1 (cst-long-suffix-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%i\"l\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-long-suffix-conc-rep-elem-of-tree-fix-cst (equal (cst-long-suffix-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-long-suffix-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-long-suffix-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-long-suffix-conc-rep-elem abnf::cst) (cst-long-suffix-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-enumeration-constant-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "enumeration-constant"))) (abnf::tree-fix (nth 0 (cst-enumeration-constant-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-enumeration-constant-conc-rep-elem (b* ((abnf::cst1 (cst-enumeration-constant-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-rep-elem-match (implies (cst-matchp abnf::cst "enumeration-constant") (b* ((abnf::cst1 (cst-enumeration-constant-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-enumeration-constant-conc-rep-elem-of-tree-fix-cst (equal (cst-enumeration-constant-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-enumeration-constant-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-enumeration-constant-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-enumeration-constant-conc-rep-elem abnf::cst) (cst-enumeration-constant-conc-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)))) (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 "block-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)))) (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 "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-white-space-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)))) (abnf::tree-fix (nth 0 (cst-white-space-conc1-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-white-space-conc1-rep-elem (b* ((abnf::cst1 (cst-white-space-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-white-space-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc1-rep-elem-of-tree-fix-cst (equal (cst-white-space-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-white-space-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-white-space-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc1-rep-elem abnf::cst) (cst-white-space-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)))) (abnf::tree-fix (nth 0 (cst-white-space-conc2-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-white-space-conc2-rep-elem (b* ((abnf::cst1 (cst-white-space-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-white-space-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc2-rep-elem-of-tree-fix-cst (equal (cst-white-space-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-white-space-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-white-space-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc2-rep-elem abnf::cst) (cst-white-space-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)))) (abnf::tree-fix (nth 0 (cst-white-space-conc3-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-white-space-conc3-rep-elem (b* ((abnf::cst1 (cst-white-space-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-white-space-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc3-rep-elem-of-tree-fix-cst (equal (cst-white-space-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-white-space-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-white-space-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc3-rep-elem abnf::cst) (cst-white-space-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)))) (abnf::tree-fix (nth 0 (cst-white-space-conc4-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-white-space-conc4-rep-elem (b* ((abnf::cst1 (cst-white-space-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-white-space-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc4-rep-elem-of-tree-fix-cst (equal (cst-white-space-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-white-space-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-white-space-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc4-rep-elem abnf::cst) (cst-white-space-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-white-space-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)))) (abnf::tree-fix (nth 0 (cst-white-space-conc5-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-white-space-conc5-rep-elem (b* ((abnf::cst1 (cst-white-space-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "white-space") (equal (cst-white-space-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-white-space-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-white-space-conc5-rep-elem-of-tree-fix-cst (equal (cst-white-space-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-white-space-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-white-space-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-white-space-conc5-rep-elem abnf::cst) (cst-white-space-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)))) (abnf::tree-fix (nth 0 (cst-lexeme-conc1-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-lexeme-conc1-rep-elem (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc1-rep-elem-of-tree-fix-cst (equal (cst-lexeme-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-lexeme-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-lexeme-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc1-rep-elem abnf::cst) (cst-lexeme-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)))) (abnf::tree-fix (nth 0 (cst-lexeme-conc2-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-lexeme-conc2-rep-elem (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "comment"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc2-rep-elem-of-tree-fix-cst (equal (cst-lexeme-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-lexeme-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-lexeme-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc2-rep-elem abnf::cst) (cst-lexeme-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lexeme-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)))) (abnf::tree-fix (nth 0 (cst-lexeme-conc3-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-lexeme-conc3-rep-elem (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "lexeme") (equal (cst-lexeme-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "white-space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lexeme-conc3-rep-elem-of-tree-fix-cst (equal (cst-lexeme-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-lexeme-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-lexeme-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lexeme-conc3-rep-elem abnf::cst) (cst-lexeme-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-expression-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "expression"))) (abnf::tree-fix (nth 0 (cst-expression-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-expression-conc-rep-elem (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc-rep-elem-match (implies (cst-matchp abnf::cst "expression") (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "assignment-expression"))) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-conc-rep-elem-of-tree-fix-cst (equal (cst-expression-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-expression-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-expression-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-expression-conc-rep-elem abnf::cst) (cst-expression-conc-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"))) (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 "conditional-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-init-declarator-list-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "init-declarator-list"))) (abnf::tree-fix (nth 0 (cst-init-declarator-list-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-init-declarator-list-conc-rep-elem (b* ((abnf::cst1 (cst-init-declarator-list-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-rep-elem-match (implies (cst-matchp abnf::cst "init-declarator-list") (b* ((abnf::cst1 (cst-init-declarator-list-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "init-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-init-declarator-list-conc-rep-elem-of-tree-fix-cst (equal (cst-init-declarator-list-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-init-declarator-list-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-init-declarator-list-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-init-declarator-list-conc-rep-elem abnf::cst) (cst-init-declarator-list-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-storage-class-specifier-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "storage-class-specifier"))) (abnf::tree-fix (nth 0 (cst-storage-class-specifier-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-storage-class-specifier-conc-rep-elem (b* ((abnf::cst1 (cst-storage-class-specifier-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-rep-elem-match (implies (cst-matchp abnf::cst "storage-class-specifier") (b* ((abnf::cst1 (cst-storage-class-specifier-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%s\"extern\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-storage-class-specifier-conc-rep-elem-of-tree-fix-cst (equal (cst-storage-class-specifier-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-storage-class-specifier-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-storage-class-specifier-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-storage-class-specifier-conc-rep-elem abnf::cst) (cst-storage-class-specifier-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-list-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator-list"))) (abnf::tree-fix (nth 0 (cst-struct-declarator-list-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-struct-declarator-list-conc-rep-elem (b* ((abnf::cst1 (cst-struct-declarator-list-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-rep-elem-match (implies (cst-matchp abnf::cst "struct-declarator-list") (b* ((abnf::cst1 (cst-struct-declarator-list-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "struct-declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-list-conc-rep-elem-of-tree-fix-cst (equal (cst-struct-declarator-list-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-struct-declarator-list-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-struct-declarator-list-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-list-conc-rep-elem abnf::cst) (cst-struct-declarator-list-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-struct-declarator-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "struct-declarator"))) (abnf::tree-fix (nth 0 (cst-struct-declarator-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-struct-declarator-conc-rep-elem (b* ((abnf::cst1 (cst-struct-declarator-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-rep-elem-match (implies (cst-matchp abnf::cst "struct-declarator") (b* ((abnf::cst1 (cst-struct-declarator-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "declarator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-struct-declarator-conc-rep-elem-of-tree-fix-cst (equal (cst-struct-declarator-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-struct-declarator-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-struct-declarator-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-struct-declarator-conc-rep-elem abnf::cst) (cst-struct-declarator-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-parameter-type-list-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "parameter-type-list"))) (abnf::tree-fix (nth 0 (cst-parameter-type-list-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-parameter-type-list-conc-rep-elem (b* ((abnf::cst1 (cst-parameter-type-list-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-rep-elem-match (implies (cst-matchp abnf::cst "parameter-type-list") (b* ((abnf::cst1 (cst-parameter-type-list-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "parameter-list"))) :rule-classes :rewrite)
Theorem:
(defthm cst-parameter-type-list-conc-rep-elem-of-tree-fix-cst (equal (cst-parameter-type-list-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-parameter-type-list-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-parameter-type-list-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-parameter-type-list-conc-rep-elem abnf::cst) (cst-parameter-type-list-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-typedef-name-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "typedef-name"))) (abnf::tree-fix (nth 0 (cst-typedef-name-conc-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-typedef-name-conc-rep-elem (b* ((abnf::cst1 (cst-typedef-name-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-rep-elem-match (implies (cst-matchp abnf::cst "typedef-name") (b* ((abnf::cst1 (cst-typedef-name-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "identifier"))) :rule-classes :rewrite)
Theorem:
(defthm cst-typedef-name-conc-rep-elem-of-tree-fix-cst (equal (cst-typedef-name-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-typedef-name-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-typedef-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-typedef-name-conc-rep-elem abnf::cst) (cst-typedef-name-conc-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)))) (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 "labeled-statement"))) :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)))) (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 "compound-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)))) (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 "expression-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)))) (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 "selection-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)))) (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 "iteration-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)))) (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 "jump-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-block-item-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)))) (abnf::tree-fix (nth 0 (cst-block-item-conc1-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-block-item-conc1-rep-elem (b* ((abnf::cst1 (cst-block-item-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-block-item-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc1-rep-elem-of-tree-fix-cst (equal (cst-block-item-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-block-item-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-block-item-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc1-rep-elem abnf::cst) (cst-block-item-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-block-item-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)))) (abnf::tree-fix (nth 0 (cst-block-item-conc2-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-block-item-conc2-rep-elem (b* ((abnf::cst1 (cst-block-item-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "block-item") (equal (cst-block-item-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-block-item-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "statement"))) :rule-classes :rewrite)
Theorem:
(defthm cst-block-item-conc2-rep-elem-of-tree-fix-cst (equal (cst-block-item-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-block-item-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-block-item-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-block-item-conc2-rep-elem abnf::cst) (cst-block-item-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-external-declaration-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)))) (abnf::tree-fix (nth 0 (cst-external-declaration-conc1-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-external-declaration-conc1-rep-elem (b* ((abnf::cst1 (cst-external-declaration-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-external-declaration-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "function-definition"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc1-rep-elem-of-tree-fix-cst (equal (cst-external-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc1-rep-elem abnf::cst) (cst-external-declaration-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-external-declaration-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)))) (abnf::tree-fix (nth 0 (cst-external-declaration-conc2-rep abnf::cst))))
Theorem:
(defthm treep-of-cst-external-declaration-conc2-rep-elem (b* ((abnf::cst1 (cst-external-declaration-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "external-declaration") (equal (cst-external-declaration-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-external-declaration-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "declaration"))) :rule-classes :rewrite)
Theorem:
(defthm cst-external-declaration-conc2-rep-elem-of-tree-fix-cst (equal (cst-external-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-external-declaration-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-external-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-external-declaration-conc2-rep-elem abnf::cst) (cst-external-declaration-conc2-rep-elem cst-equiv))) :rule-classes :congruence)