Tree operations specialized to *grammar*.
Function:
(defun cst-matchp$ (abnf::tree abnf::elem) (declare (xargs :guard (and (abnf::treep abnf::tree) (abnf::elementp abnf::elem)))) (let ((__function__ 'cst-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-terminatedp abnf::tree) (abnf::tree-match-element-p abnf::tree abnf::elem *grammar*))))
Theorem:
(defthm booleanp-of-cst-matchp$ (b* ((abnf::yes/no (cst-matchp$ abnf::tree abnf::elem))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-matchp$-of-tree-fix-tree (equal (cst-matchp$ (abnf::tree-fix abnf::tree) abnf::elem) (cst-matchp$ abnf::tree abnf::elem)))
Theorem:
(defthm cst-matchp$-tree-equiv-congruence-on-tree (implies (abnf::tree-equiv abnf::tree tree-equiv) (equal (cst-matchp$ abnf::tree abnf::elem) (cst-matchp$ tree-equiv abnf::elem))) :rule-classes :congruence)
Theorem:
(defthm cst-matchp$-of-element-fix-elem (equal (cst-matchp$ abnf::tree (abnf::element-fix abnf::elem)) (cst-matchp$ abnf::tree abnf::elem)))
Theorem:
(defthm cst-matchp$-element-equiv-congruence-on-elem (implies (abnf::element-equiv abnf::elem elem-equiv) (equal (cst-matchp$ abnf::tree abnf::elem) (cst-matchp$ abnf::tree elem-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-elem-matchp$ (abnf::trees abnf::elem) (declare (xargs :guard (and (abnf::tree-listp abnf::trees) (abnf::elementp abnf::elem)))) (let ((__function__ 'cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-terminatedp abnf::trees) (abnf::tree-list-match-element-p abnf::trees abnf::elem *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-elem-matchp$ (b* ((abnf::yes/no (cst-list-elem-matchp$ abnf::trees abnf::elem))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-elem-matchp$-of-tree-list-fix-trees (equal (cst-list-elem-matchp$ (abnf::tree-list-fix abnf::trees) abnf::elem) (cst-list-elem-matchp$ abnf::trees abnf::elem)))
Theorem:
(defthm cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (abnf::tree-list-equiv abnf::trees trees-equiv) (equal (cst-list-elem-matchp$ abnf::trees abnf::elem) (cst-list-elem-matchp$ trees-equiv abnf::elem))) :rule-classes :congruence)
Theorem:
(defthm cst-list-elem-matchp$-of-element-fix-elem (equal (cst-list-elem-matchp$ abnf::trees (abnf::element-fix abnf::elem)) (cst-list-elem-matchp$ abnf::trees abnf::elem)))
Theorem:
(defthm cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (abnf::element-equiv abnf::elem elem-equiv) (equal (cst-list-elem-matchp$ abnf::trees abnf::elem) (cst-list-elem-matchp$ abnf::trees elem-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-rep-matchp$ (abnf::trees abnf::rep) (declare (xargs :guard (and (abnf::tree-listp abnf::trees) (abnf::repetitionp abnf::rep)))) (let ((__function__ 'cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-terminatedp abnf::trees) (abnf::tree-list-match-repetition-p abnf::trees abnf::rep *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-rep-matchp$ (b* ((abnf::yes/no (cst-list-rep-matchp$ abnf::trees abnf::rep))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-rep-matchp$-of-tree-list-fix-trees (equal (cst-list-rep-matchp$ (abnf::tree-list-fix abnf::trees) abnf::rep) (cst-list-rep-matchp$ abnf::trees abnf::rep)))
Theorem:
(defthm cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (abnf::tree-list-equiv abnf::trees trees-equiv) (equal (cst-list-rep-matchp$ abnf::trees abnf::rep) (cst-list-rep-matchp$ trees-equiv abnf::rep))) :rule-classes :congruence)
Theorem:
(defthm cst-list-rep-matchp$-of-repetition-fix-rep (equal (cst-list-rep-matchp$ abnf::trees (abnf::repetition-fix abnf::rep)) (cst-list-rep-matchp$ abnf::trees abnf::rep)))
Theorem:
(defthm cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (abnf::repetition-equiv abnf::rep rep-equiv) (equal (cst-list-rep-matchp$ abnf::trees abnf::rep) (cst-list-rep-matchp$ abnf::trees rep-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-list-conc-matchp$ (abnf::treess abnf::conc) (declare (xargs :guard (and (abnf::tree-list-listp abnf::treess) (abnf::concatenationp abnf::conc)))) (let ((__function__ 'cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-list-terminatedp abnf::treess) (abnf::tree-list-list-match-concatenation-p abnf::treess abnf::conc *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-list-conc-matchp$ (b* ((abnf::yes/no (cst-list-list-conc-matchp$ abnf::treess abnf::conc))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (cst-list-list-conc-matchp$ (abnf::tree-list-list-fix abnf::treess) abnf::conc) (cst-list-list-conc-matchp$ abnf::treess abnf::conc)))
Theorem:
(defthm cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (abnf::tree-list-list-equiv abnf::treess treess-equiv) (equal (cst-list-list-conc-matchp$ abnf::treess abnf::conc) (cst-list-list-conc-matchp$ treess-equiv abnf::conc))) :rule-classes :congruence)
Theorem:
(defthm cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (cst-list-list-conc-matchp$ abnf::treess (abnf::concatenation-fix abnf::conc)) (cst-list-list-conc-matchp$ abnf::treess abnf::conc)))
Theorem:
(defthm cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (abnf::concatenation-equiv abnf::conc conc-equiv) (equal (cst-list-list-conc-matchp$ abnf::treess abnf::conc) (cst-list-list-conc-matchp$ abnf::treess conc-equiv))) :rule-classes :congruence)
Function:
(defun cst-list-list-alt-matchp$ (abnf::treess abnf::alt) (declare (xargs :guard (and (abnf::tree-list-listp abnf::treess) (abnf::alternationp abnf::alt)))) (let ((__function__ 'cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (abnf::tree-list-list-terminatedp abnf::treess) (abnf::tree-list-list-match-alternation-p abnf::treess abnf::alt *grammar*))))
Theorem:
(defthm booleanp-of-cst-list-list-alt-matchp$ (b* ((abnf::yes/no (cst-list-list-alt-matchp$ abnf::treess abnf::alt))) (booleanp abnf::yes/no)) :rule-classes :rewrite)
Theorem:
(defthm cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (cst-list-list-alt-matchp$ (abnf::tree-list-list-fix abnf::treess) abnf::alt) (cst-list-list-alt-matchp$ abnf::treess abnf::alt)))
Theorem:
(defthm cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (abnf::tree-list-list-equiv abnf::treess treess-equiv) (equal (cst-list-list-alt-matchp$ abnf::treess abnf::alt) (cst-list-list-alt-matchp$ treess-equiv abnf::alt))) :rule-classes :congruence)
Theorem:
(defthm cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (cst-list-list-alt-matchp$ abnf::treess (abnf::alternation-fix abnf::alt)) (cst-list-list-alt-matchp$ abnf::treess abnf::alt)))
Theorem:
(defthm cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (abnf::alternation-equiv abnf::alt alt-equiv) (equal (cst-list-list-alt-matchp$ abnf::treess abnf::alt) (cst-list-list-alt-matchp$ abnf::treess alt-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x21-23-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x21-23"))) (let ((__function__ 'cst-%x21-23-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x21-23-nat (b* ((nat (cst-%x21-23-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x21-23-nat-of-tree-fix-cst (equal (cst-%x21-23-nat (abnf::tree-fix abnf::cst)) (cst-%x21-23-nat abnf::cst)))
Theorem:
(defthm cst-%x21-23-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x21-23-nat abnf::cst) (cst-%x21-23-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x25-26-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x25-26"))) (let ((__function__ 'cst-%x25-26-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x25-26-nat (b* ((nat (cst-%x25-26-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x25-26-nat-of-tree-fix-cst (equal (cst-%x25-26-nat (abnf::tree-fix abnf::cst)) (cst-%x25-26-nat abnf::cst)))
Theorem:
(defthm cst-%x25-26-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x25-26-nat abnf::cst) (cst-%x25-26-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x25-29-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x25-29"))) (let ((__function__ 'cst-%x25-29-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x25-29-nat (b* ((nat (cst-%x25-29-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x25-29-nat-of-tree-fix-cst (equal (cst-%x25-29-nat (abnf::tree-fix abnf::cst)) (cst-%x25-29-nat abnf::cst)))
Theorem:
(defthm cst-%x25-29-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x25-29-nat abnf::cst) (cst-%x25-29-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x25-2f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x25-2F"))) (let ((__function__ 'cst-%x25-2f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x25-2f-nat (b* ((nat (cst-%x25-2f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x25-2f-nat-of-tree-fix-cst (equal (cst-%x25-2f-nat (abnf::tree-fix abnf::cst)) (cst-%x25-2f-nat abnf::cst)))
Theorem:
(defthm cst-%x25-2f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x25-2f-nat abnf::cst) (cst-%x25-2f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x28-2f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x28-2F"))) (let ((__function__ 'cst-%x28-2f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x28-2f-nat (b* ((nat (cst-%x28-2f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x28-2f-nat-of-tree-fix-cst (equal (cst-%x28-2f-nat (abnf::tree-fix abnf::cst)) (cst-%x28-2f-nat abnf::cst)))
Theorem:
(defthm cst-%x28-2f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x28-2f-nat abnf::cst) (cst-%x28-2f-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"))) (let ((__function__ 'cst-%x2b-2e-nat)) (declare (ignorable __function__)) (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-2f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x2B-2F"))) (let ((__function__ 'cst-%x2b-2f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x2b-2f-nat (b* ((nat (cst-%x2b-2f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x2b-2f-nat-of-tree-fix-cst (equal (cst-%x2b-2f-nat (abnf::tree-fix abnf::cst)) (cst-%x2b-2f-nat abnf::cst)))
Theorem:
(defthm cst-%x2b-2f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x2b-2f-nat abnf::cst) (cst-%x2b-2f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x30-37-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x30-37"))) (let ((__function__ 'cst-%x30-37-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x30-37-nat (b* ((nat (cst-%x30-37-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x30-37-nat-of-tree-fix-cst (equal (cst-%x30-37-nat (abnf::tree-fix abnf::cst)) (cst-%x30-37-nat abnf::cst)))
Theorem:
(defthm cst-%x30-37-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x30-37-nat abnf::cst) (cst-%x30-37-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x30-39-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x30-39"))) (let ((__function__ 'cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x30-39-nat (b* ((nat (cst-%x30-39-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x30-39-nat-of-tree-fix-cst (equal (cst-%x30-39-nat (abnf::tree-fix abnf::cst)) (cst-%x30-39-nat abnf::cst)))
Theorem:
(defthm cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x30-39-nat abnf::cst) (cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x31-39-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x31-39"))) (let ((__function__ 'cst-%x31-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x31-39-nat (b* ((nat (cst-%x31-39-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x31-39-nat-of-tree-fix-cst (equal (cst-%x31-39-nat (abnf::tree-fix abnf::cst)) (cst-%x31-39-nat abnf::cst)))
Theorem:
(defthm cst-%x31-39-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x31-39-nat abnf::cst) (cst-%x31-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x3a-3f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x3A-3F"))) (let ((__function__ 'cst-%x3a-3f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x3a-3f-nat (b* ((nat (cst-%x3a-3f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x3a-3f-nat-of-tree-fix-cst (equal (cst-%x3a-3f-nat (abnf::tree-fix abnf::cst)) (cst-%x3a-3f-nat abnf::cst)))
Theorem:
(defthm cst-%x3a-3f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x3a-3f-nat abnf::cst) (cst-%x3a-3f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x41-46-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x41-46"))) (let ((__function__ 'cst-%x41-46-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x41-46-nat (b* ((nat (cst-%x41-46-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x41-46-nat-of-tree-fix-cst (equal (cst-%x41-46-nat (abnf::tree-fix abnf::cst)) (cst-%x41-46-nat abnf::cst)))
Theorem:
(defthm cst-%x41-46-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x41-46-nat abnf::cst) (cst-%x41-46-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x41-5a-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x41-5A"))) (let ((__function__ 'cst-%x41-5a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x41-5a-nat (b* ((nat (cst-%x41-5a-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x41-5a-nat-of-tree-fix-cst (equal (cst-%x41-5a-nat (abnf::tree-fix abnf::cst)) (cst-%x41-5a-nat abnf::cst)))
Theorem:
(defthm cst-%x41-5a-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x41-5a-nat abnf::cst) (cst-%x41-5a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x5b-5f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x5B-5F"))) (let ((__function__ 'cst-%x5b-5f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x5b-5f-nat (b* ((nat (cst-%x5b-5f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x5b-5f-nat-of-tree-fix-cst (equal (cst-%x5b-5f-nat (abnf::tree-fix abnf::cst)) (cst-%x5b-5f-nat abnf::cst)))
Theorem:
(defthm cst-%x5b-5f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x5b-5f-nat abnf::cst) (cst-%x5b-5f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x5d-5f-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x5D-5F"))) (let ((__function__ 'cst-%x5d-5f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x5d-5f-nat (b* ((nat (cst-%x5d-5f-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x5d-5f-nat-of-tree-fix-cst (equal (cst-%x5d-5f-nat (abnf::tree-fix abnf::cst)) (cst-%x5d-5f-nat abnf::cst)))
Theorem:
(defthm cst-%x5d-5f-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x5d-5f-nat abnf::cst) (cst-%x5d-5f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x61-66-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x61-66"))) (let ((__function__ 'cst-%x61-66-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x61-66-nat (b* ((nat (cst-%x61-66-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x61-66-nat-of-tree-fix-cst (equal (cst-%x61-66-nat (abnf::tree-fix abnf::cst)) (cst-%x61-66-nat abnf::cst)))
Theorem:
(defthm cst-%x61-66-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x61-66-nat abnf::cst) (cst-%x61-66-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x61-7a-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x61-7A"))) (let ((__function__ 'cst-%x61-7a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x61-7a-nat (b* ((nat (cst-%x61-7a-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x61-7a-nat-of-tree-fix-cst (equal (cst-%x61-7a-nat (abnf::tree-fix abnf::cst)) (cst-%x61-7a-nat abnf::cst)))
Theorem:
(defthm cst-%x61-7a-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x61-7a-nat abnf::cst) (cst-%x61-7a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x7b-7e-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x7B-7E"))) (let ((__function__ 'cst-%x7b-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x7b-7e-nat (b* ((nat (cst-%x7b-7e-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x7b-7e-nat-of-tree-fix-cst (equal (cst-%x7b-7e-nat (abnf::tree-fix abnf::cst)) (cst-%x7b-7e-nat abnf::cst)))
Theorem:
(defthm cst-%x7b-7e-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x7b-7e-nat abnf::cst) (cst-%x7b-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x80-2029-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x80-2029"))) (let ((__function__ 'cst-%x80-2029-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x80-2029-nat (b* ((nat (cst-%x80-2029-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x80-2029-nat-of-tree-fix-cst (equal (cst-%x80-2029-nat (abnf::tree-fix abnf::cst)) (cst-%x80-2029-nat abnf::cst)))
Theorem:
(defthm cst-%x80-2029-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x80-2029-nat abnf::cst) (cst-%x80-2029-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x202f-2065-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x202F-2065"))) (let ((__function__ 'cst-%x202f-2065-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x202f-2065-nat (b* ((nat (cst-%x202f-2065-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x202f-2065-nat-of-tree-fix-cst (equal (cst-%x202f-2065-nat (abnf::tree-fix abnf::cst)) (cst-%x202f-2065-nat abnf::cst)))
Theorem:
(defthm cst-%x202f-2065-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x202f-2065-nat abnf::cst) (cst-%x202f-2065-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%x206a-d7ff-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%x206A-D7FF"))) (let ((__function__ 'cst-%x206a-d7ff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%x206a-d7ff-nat (b* ((nat (cst-%x206a-d7ff-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%x206a-d7ff-nat-of-tree-fix-cst (equal (cst-%x206a-d7ff-nat (abnf::tree-fix abnf::cst)) (cst-%x206a-d7ff-nat abnf::cst)))
Theorem:
(defthm cst-%x206a-d7ff-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%x206a-d7ff-nat abnf::cst) (cst-%x206a-d7ff-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-%xe000-10ffff-nat (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "%xE000-10FFFF"))) (let ((__function__ 'cst-%xe000-10ffff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (abnf::tree-leafterm->get abnf::cst)))))
Theorem:
(defthm natp-of-cst-%xe000-10ffff-nat (b* ((nat (cst-%xe000-10ffff-nat abnf::cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm cst-%xe000-10ffff-nat-of-tree-fix-cst (equal (cst-%xe000-10ffff-nat (abnf::tree-fix abnf::cst)) (cst-%xe000-10ffff-nat abnf::cst)))
Theorem:
(defthm cst-%xe000-10ffff-nat-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-%xe000-10ffff-nat abnf::cst) (cst-%xe000-10ffff-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-%x21-23-nat-bounds (implies (cst-matchp abnf::cst "%x21-23") (and (<= 33 (cst-%x21-23-nat abnf::cst)) (<= (cst-%x21-23-nat abnf::cst) 35))) :rule-classes :linear)
Theorem:
(defthm cst-%x25-26-nat-bounds (implies (cst-matchp abnf::cst "%x25-26") (and (<= 37 (cst-%x25-26-nat abnf::cst)) (<= (cst-%x25-26-nat abnf::cst) 38))) :rule-classes :linear)
Theorem:
(defthm cst-%x25-29-nat-bounds (implies (cst-matchp abnf::cst "%x25-29") (and (<= 37 (cst-%x25-29-nat abnf::cst)) (<= (cst-%x25-29-nat abnf::cst) 41))) :rule-classes :linear)
Theorem:
(defthm cst-%x25-2f-nat-bounds (implies (cst-matchp abnf::cst "%x25-2F") (and (<= 37 (cst-%x25-2f-nat abnf::cst)) (<= (cst-%x25-2f-nat abnf::cst) 47))) :rule-classes :linear)
Theorem:
(defthm cst-%x28-2f-nat-bounds (implies (cst-matchp abnf::cst "%x28-2F") (and (<= 40 (cst-%x28-2f-nat abnf::cst)) (<= (cst-%x28-2f-nat abnf::cst) 47))) :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-2f-nat-bounds (implies (cst-matchp abnf::cst "%x2B-2F") (and (<= 43 (cst-%x2b-2f-nat abnf::cst)) (<= (cst-%x2b-2f-nat abnf::cst) 47))) :rule-classes :linear)
Theorem:
(defthm cst-%x30-37-nat-bounds (implies (cst-matchp abnf::cst "%x30-37") (and (<= 48 (cst-%x30-37-nat abnf::cst)) (<= (cst-%x30-37-nat abnf::cst) 55))) :rule-classes :linear)
Theorem:
(defthm cst-%x30-39-nat-bounds (implies (cst-matchp abnf::cst "%x30-39") (and (<= 48 (cst-%x30-39-nat abnf::cst)) (<= (cst-%x30-39-nat abnf::cst) 57))) :rule-classes :linear)
Theorem:
(defthm cst-%x31-39-nat-bounds (implies (cst-matchp abnf::cst "%x31-39") (and (<= 49 (cst-%x31-39-nat abnf::cst)) (<= (cst-%x31-39-nat abnf::cst) 57))) :rule-classes :linear)
Theorem:
(defthm cst-%x3a-3f-nat-bounds (implies (cst-matchp abnf::cst "%x3A-3F") (and (<= 58 (cst-%x3a-3f-nat abnf::cst)) (<= (cst-%x3a-3f-nat abnf::cst) 63))) :rule-classes :linear)
Theorem:
(defthm cst-%x41-46-nat-bounds (implies (cst-matchp abnf::cst "%x41-46") (and (<= 65 (cst-%x41-46-nat abnf::cst)) (<= (cst-%x41-46-nat abnf::cst) 70))) :rule-classes :linear)
Theorem:
(defthm cst-%x41-5a-nat-bounds (implies (cst-matchp abnf::cst "%x41-5A") (and (<= 65 (cst-%x41-5a-nat abnf::cst)) (<= (cst-%x41-5a-nat abnf::cst) 90))) :rule-classes :linear)
Theorem:
(defthm cst-%x5b-5f-nat-bounds (implies (cst-matchp abnf::cst "%x5B-5F") (and (<= 91 (cst-%x5b-5f-nat abnf::cst)) (<= (cst-%x5b-5f-nat abnf::cst) 95))) :rule-classes :linear)
Theorem:
(defthm cst-%x5d-5f-nat-bounds (implies (cst-matchp abnf::cst "%x5D-5F") (and (<= 93 (cst-%x5d-5f-nat abnf::cst)) (<= (cst-%x5d-5f-nat abnf::cst) 95))) :rule-classes :linear)
Theorem:
(defthm cst-%x61-66-nat-bounds (implies (cst-matchp abnf::cst "%x61-66") (and (<= 97 (cst-%x61-66-nat abnf::cst)) (<= (cst-%x61-66-nat abnf::cst) 102))) :rule-classes :linear)
Theorem:
(defthm cst-%x61-7a-nat-bounds (implies (cst-matchp abnf::cst "%x61-7A") (and (<= 97 (cst-%x61-7a-nat abnf::cst)) (<= (cst-%x61-7a-nat abnf::cst) 122))) :rule-classes :linear)
Theorem:
(defthm cst-%x7b-7e-nat-bounds (implies (cst-matchp abnf::cst "%x7B-7E") (and (<= 123 (cst-%x7b-7e-nat abnf::cst)) (<= (cst-%x7b-7e-nat abnf::cst) 126))) :rule-classes :linear)
Theorem:
(defthm cst-%x80-2029-nat-bounds (implies (cst-matchp abnf::cst "%x80-2029") (and (<= 128 (cst-%x80-2029-nat abnf::cst)) (<= (cst-%x80-2029-nat abnf::cst) 8233))) :rule-classes :linear)
Theorem:
(defthm cst-%x202f-2065-nat-bounds (implies (cst-matchp abnf::cst "%x202F-2065") (and (<= 8239 (cst-%x202f-2065-nat abnf::cst)) (<= (cst-%x202f-2065-nat abnf::cst) 8293))) :rule-classes :linear)
Theorem:
(defthm cst-%x206a-d7ff-nat-bounds (implies (cst-matchp abnf::cst "%x206A-D7FF") (and (<= 8298 (cst-%x206a-d7ff-nat abnf::cst)) (<= (cst-%x206a-d7ff-nat abnf::cst) 55295))) :rule-classes :linear)
Theorem:
(defthm cst-%xe000-10ffff-nat-bounds (implies (cst-matchp abnf::cst "%xE000-10FFFF") (and (<= 57344 (cst-%xe000-10ffff-nat abnf::cst)) (<= (cst-%xe000-10ffff-nat abnf::cst) 1114111))) :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-"/="-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-":"-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-"~"-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"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"l"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"l\"") (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"u"-LEAFTERM| (implies (cst-matchp abnf::cst "%i\"u\"") (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-%s"L"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"L\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"L'"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"L'\"") (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"\\U"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\U\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\a"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\a\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\b"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\b\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\f"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\f\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\n"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\n\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\r"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\r\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\t"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\t\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\u"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\u\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\v"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\v\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"\\x"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"\\x\"") (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"__alignof__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__alignof__\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"__asm__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__asm__\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"__attribute__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__attribute__\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"__extension__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__extension__\"") (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"__inline__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__inline__\"") (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"__restrict__"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"__restrict__\"") (equal (abnf::tree-kind abnf::cst) :leafterm)))
Theorem:
(defthm |CST-%s"asm"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"asm\"") (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"u8"-LEAFTERM| (implies (cst-matchp abnf::cst "%s\"u8\"") (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-uppercase-letter-nonleaf (implies (cst-matchp abnf::cst "uppercase-letter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-lowercase-letter-nonleaf (implies (cst-matchp abnf::cst "lowercase-letter") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-letter-nonleaf (implies (cst-matchp abnf::cst "letter") (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-double-quote-nonleaf (implies (cst-matchp abnf::cst "double-quote") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-graphic-character-nonleaf (implies (cst-matchp abnf::cst "graphic-character") (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-horizontal-tab-nonleaf (implies (cst-matchp abnf::cst "horizontal-tab") (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-control-character-nonleaf (implies (cst-matchp abnf::cst "control-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-character-nonleaf (implies (cst-matchp abnf::cst "basic-character") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-safe-nonascii-nonleaf (implies (cst-matchp abnf::cst "safe-nonascii") (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-carriage-return-nonleaf (implies (cst-matchp abnf::cst "carriage-return") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-extended-character-nonleaf (implies (cst-matchp abnf::cst "extended-character") (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-new-line-nonleaf (implies (cst-matchp abnf::cst "new-line") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-extended-character-not-new-line-nonleaf (implies (cst-matchp abnf::cst "extended-character-not-new-line") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-graphic-character-not-star-nonleaf (implies (cst-matchp abnf::cst "graphic-character-not-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-nonleaf (implies (cst-matchp abnf::cst "graphic-character-not-star-or-slash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-nonleaf (implies (cst-matchp abnf::cst "graphic-character-not-single-quote-or-backslash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-nonleaf (implies (cst-matchp abnf::cst "graphic-character-not-double-quote-or-backslash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-character-not-star-nonleaf (implies (cst-matchp abnf::cst "basic-character-not-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-nonleaf (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-nonleaf (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-nonleaf (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-not-new-line-nonleaf (implies (cst-matchp abnf::cst "character-not-new-line") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-not-star-nonleaf (implies (cst-matchp abnf::cst "character-not-star") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-not-star-or-slash-nonleaf (implies (cst-matchp abnf::cst "character-not-star-or-slash") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-nonleaf (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-nonleaf (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-white-space-nonleaf (implies (cst-matchp abnf::cst "white-space") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-comment-nonleaf (implies (cst-matchp abnf::cst "comment") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-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-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-gcc-keyword-nonleaf (implies (cst-matchp abnf::cst "gcc-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-universal-character-name-nonleaf (implies (cst-matchp abnf::cst "universal-character-name") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hex-quad-nonleaf (implies (cst-matchp abnf::cst "hex-quad") (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-floating-constant-nonleaf (implies (cst-matchp abnf::cst "floating-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-decimal-floating-constant-nonleaf (implies (cst-matchp abnf::cst "decimal-floating-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-floating-constant-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-floating-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-fractional-constant-nonleaf (implies (cst-matchp abnf::cst "fractional-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-exponent-part-nonleaf (implies (cst-matchp abnf::cst "exponent-part") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-sign-nonleaf (implies (cst-matchp abnf::cst "sign") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-digit-sequence-nonleaf (implies (cst-matchp abnf::cst "digit-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-fractional-constant-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-fractional-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-binary-exponent-part-nonleaf (implies (cst-matchp abnf::cst "binary-exponent-part") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-digit-sequence-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-digit-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-floating-suffix-nonleaf (implies (cst-matchp abnf::cst "floating-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-character-constant-nonleaf (implies (cst-matchp abnf::cst "character-constant") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-c-char-sequence-nonleaf (implies (cst-matchp abnf::cst "c-char-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-c-char-nonleaf (implies (cst-matchp abnf::cst "c-char") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-escape-sequence-nonleaf (implies (cst-matchp abnf::cst "escape-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-simple-escape-sequence-nonleaf (implies (cst-matchp abnf::cst "simple-escape-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-octal-escape-sequence-nonleaf (implies (cst-matchp abnf::cst "octal-escape-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-hexadecimal-escape-sequence-nonleaf (implies (cst-matchp abnf::cst "hexadecimal-escape-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-string-literal-nonleaf (implies (cst-matchp abnf::cst "string-literal") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-encoding-prefix-nonleaf (implies (cst-matchp abnf::cst "encoding-prefix") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-s-char-sequence-nonleaf (implies (cst-matchp abnf::cst "s-char-sequence") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-s-char-nonleaf (implies (cst-matchp abnf::cst "s-char") (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-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-generic-selection-nonleaf (implies (cst-matchp abnf::cst "generic-selection") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-generic-assoc-list-nonleaf (implies (cst-matchp abnf::cst "generic-assoc-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-generic-association-nonleaf (implies (cst-matchp abnf::cst "generic-association") (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-attribute-parameters-nonleaf (implies (cst-matchp abnf::cst "attribute-parameters") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-attribute-nonleaf (implies (cst-matchp abnf::cst "attribute") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-attribute-list-nonleaf (implies (cst-matchp abnf::cst "attribute-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-attribute-specifier-nonleaf (implies (cst-matchp abnf::cst "attribute-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-asm-name-specifier-nonleaf (implies (cst-matchp abnf::cst "asm-name-specifier") (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-enumerator-list-nonleaf (implies (cst-matchp abnf::cst "enumerator-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-enumerator-nonleaf (implies (cst-matchp abnf::cst "enumerator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-atomic-type-specifier-nonleaf (implies (cst-matchp abnf::cst "atomic-type-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-type-qualifier-nonleaf (implies (cst-matchp abnf::cst "type-qualifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-function-specifier-nonleaf (implies (cst-matchp abnf::cst "function-specifier") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-alignment-specifier-nonleaf (implies (cst-matchp abnf::cst "alignment-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-type-qualifier-list-nonleaf (implies (cst-matchp abnf::cst "type-qualifier-list") (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-identifier-list-nonleaf (implies (cst-matchp abnf::cst "identifier-list") (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-designation-nonleaf (implies (cst-matchp abnf::cst "designation") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-designator-list-nonleaf (implies (cst-matchp abnf::cst "designator-list") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-designator-nonleaf (implies (cst-matchp abnf::cst "designator") (equal (abnf::tree-kind abnf::cst) :nonleaf)))
Theorem:
(defthm cst-static-assert-declaration-nonleaf (implies (cst-matchp abnf::cst "static-assert-declaration") (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-uppercase-letter-rulename (implies (cst-matchp abnf::cst "uppercase-letter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "uppercase-letter"))))
Theorem:
(defthm cst-lowercase-letter-rulename (implies (cst-matchp abnf::cst "lowercase-letter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "lowercase-letter"))))
Theorem:
(defthm cst-letter-rulename (implies (cst-matchp abnf::cst "letter") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "letter"))))
Theorem:
(defthm cst-digit-rulename (implies (cst-matchp abnf::cst "digit") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digit"))))
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-graphic-character-rulename (implies (cst-matchp abnf::cst "graphic-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "graphic-character"))))
Theorem:
(defthm cst-space-rulename (implies (cst-matchp abnf::cst "space") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "space"))))
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-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-control-character-rulename (implies (cst-matchp abnf::cst "control-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "control-character"))))
Theorem:
(defthm cst-basic-character-rulename (implies (cst-matchp abnf::cst "basic-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-character"))))
Theorem:
(defthm cst-safe-nonascii-rulename (implies (cst-matchp abnf::cst "safe-nonascii") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "safe-nonascii"))))
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-carriage-return-rulename (implies (cst-matchp abnf::cst "carriage-return") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "carriage-return"))))
Theorem:
(defthm cst-extended-character-rulename (implies (cst-matchp abnf::cst "extended-character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "extended-character"))))
Theorem:
(defthm cst-character-rulename (implies (cst-matchp abnf::cst "character") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character"))))
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-extended-character-not-new-line-rulename (implies (cst-matchp abnf::cst "extended-character-not-new-line") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "extended-character-not-new-line"))))
Theorem:
(defthm cst-graphic-character-not-star-rulename (implies (cst-matchp abnf::cst "graphic-character-not-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "graphic-character-not-star"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-rulename (implies (cst-matchp abnf::cst "graphic-character-not-star-or-slash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "graphic-character-not-star-or-slash"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-rulename (implies (cst-matchp abnf::cst "graphic-character-not-single-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "graphic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-rulename (implies (cst-matchp abnf::cst "graphic-character-not-double-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "graphic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-star-rulename (implies (cst-matchp abnf::cst "basic-character-not-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-character-not-star"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-rulename (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-character-not-star-or-slash"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-rulename (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-rulename (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "basic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-new-line-rulename (implies (cst-matchp abnf::cst "character-not-new-line") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-not-new-line"))))
Theorem:
(defthm cst-character-not-star-rulename (implies (cst-matchp abnf::cst "character-not-star") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-not-star"))))
Theorem:
(defthm cst-character-not-star-or-slash-rulename (implies (cst-matchp abnf::cst "character-not-star-or-slash") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-not-star-or-slash"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-rulename (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-not-single-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-rulename (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-not-double-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-white-space-rulename (implies (cst-matchp abnf::cst "white-space") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "white-space"))))
Theorem:
(defthm cst-comment-rulename (implies (cst-matchp abnf::cst "comment") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "comment"))))
Theorem:
(defthm cst-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-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-gcc-keyword-rulename (implies (cst-matchp abnf::cst "gcc-keyword") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "gcc-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-universal-character-name-rulename (implies (cst-matchp abnf::cst "universal-character-name") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "universal-character-name"))))
Theorem:
(defthm cst-hex-quad-rulename (implies (cst-matchp abnf::cst "hex-quad") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hex-quad"))))
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-floating-constant-rulename (implies (cst-matchp abnf::cst "floating-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "floating-constant"))))
Theorem:
(defthm cst-decimal-floating-constant-rulename (implies (cst-matchp abnf::cst "decimal-floating-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "decimal-floating-constant"))))
Theorem:
(defthm cst-hexadecimal-floating-constant-rulename (implies (cst-matchp abnf::cst "hexadecimal-floating-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-floating-constant"))))
Theorem:
(defthm cst-fractional-constant-rulename (implies (cst-matchp abnf::cst "fractional-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "fractional-constant"))))
Theorem:
(defthm cst-exponent-part-rulename (implies (cst-matchp abnf::cst "exponent-part") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "exponent-part"))))
Theorem:
(defthm cst-sign-rulename (implies (cst-matchp abnf::cst "sign") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "sign"))))
Theorem:
(defthm cst-digit-sequence-rulename (implies (cst-matchp abnf::cst "digit-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "digit-sequence"))))
Theorem:
(defthm cst-hexadecimal-fractional-constant-rulename (implies (cst-matchp abnf::cst "hexadecimal-fractional-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-fractional-constant"))))
Theorem:
(defthm cst-binary-exponent-part-rulename (implies (cst-matchp abnf::cst "binary-exponent-part") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "binary-exponent-part"))))
Theorem:
(defthm cst-hexadecimal-digit-sequence-rulename (implies (cst-matchp abnf::cst "hexadecimal-digit-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-digit-sequence"))))
Theorem:
(defthm cst-floating-suffix-rulename (implies (cst-matchp abnf::cst "floating-suffix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "floating-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-character-constant-rulename (implies (cst-matchp abnf::cst "character-constant") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "character-constant"))))
Theorem:
(defthm cst-c-char-sequence-rulename (implies (cst-matchp abnf::cst "c-char-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "c-char-sequence"))))
Theorem:
(defthm cst-c-char-rulename (implies (cst-matchp abnf::cst "c-char") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "c-char"))))
Theorem:
(defthm cst-escape-sequence-rulename (implies (cst-matchp abnf::cst "escape-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "escape-sequence"))))
Theorem:
(defthm cst-simple-escape-sequence-rulename (implies (cst-matchp abnf::cst "simple-escape-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "simple-escape-sequence"))))
Theorem:
(defthm cst-octal-escape-sequence-rulename (implies (cst-matchp abnf::cst "octal-escape-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "octal-escape-sequence"))))
Theorem:
(defthm cst-hexadecimal-escape-sequence-rulename (implies (cst-matchp abnf::cst "hexadecimal-escape-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "hexadecimal-escape-sequence"))))
Theorem:
(defthm cst-string-literal-rulename (implies (cst-matchp abnf::cst "string-literal") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "string-literal"))))
Theorem:
(defthm cst-encoding-prefix-rulename (implies (cst-matchp abnf::cst "encoding-prefix") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "encoding-prefix"))))
Theorem:
(defthm cst-s-char-sequence-rulename (implies (cst-matchp abnf::cst "s-char-sequence") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "s-char-sequence"))))
Theorem:
(defthm cst-s-char-rulename (implies (cst-matchp abnf::cst "s-char") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "s-char"))))
Theorem:
(defthm cst-punctuator-rulename (implies (cst-matchp abnf::cst "punctuator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "punctuator"))))
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-generic-selection-rulename (implies (cst-matchp abnf::cst "generic-selection") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "generic-selection"))))
Theorem:
(defthm cst-generic-assoc-list-rulename (implies (cst-matchp abnf::cst "generic-assoc-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "generic-assoc-list"))))
Theorem:
(defthm cst-generic-association-rulename (implies (cst-matchp abnf::cst "generic-association") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "generic-association"))))
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-attribute-parameters-rulename (implies (cst-matchp abnf::cst "attribute-parameters") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "attribute-parameters"))))
Theorem:
(defthm cst-attribute-rulename (implies (cst-matchp abnf::cst "attribute") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "attribute"))))
Theorem:
(defthm cst-attribute-list-rulename (implies (cst-matchp abnf::cst "attribute-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "attribute-list"))))
Theorem:
(defthm cst-attribute-specifier-rulename (implies (cst-matchp abnf::cst "attribute-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "attribute-specifier"))))
Theorem:
(defthm cst-asm-name-specifier-rulename (implies (cst-matchp abnf::cst "asm-name-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "asm-name-specifier"))))
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-enumerator-list-rulename (implies (cst-matchp abnf::cst "enumerator-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enumerator-list"))))
Theorem:
(defthm cst-enumerator-rulename (implies (cst-matchp abnf::cst "enumerator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "enumerator"))))
Theorem:
(defthm cst-atomic-type-specifier-rulename (implies (cst-matchp abnf::cst "atomic-type-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "atomic-type-specifier"))))
Theorem:
(defthm cst-type-qualifier-rulename (implies (cst-matchp abnf::cst "type-qualifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-qualifier"))))
Theorem:
(defthm cst-function-specifier-rulename (implies (cst-matchp abnf::cst "function-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "function-specifier"))))
Theorem:
(defthm cst-alignment-specifier-rulename (implies (cst-matchp abnf::cst "alignment-specifier") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "alignment-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-type-qualifier-list-rulename (implies (cst-matchp abnf::cst "type-qualifier-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "type-qualifier-list"))))
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-identifier-list-rulename (implies (cst-matchp abnf::cst "identifier-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "identifier-list"))))
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-designation-rulename (implies (cst-matchp abnf::cst "designation") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "designation"))))
Theorem:
(defthm cst-designator-list-rulename (implies (cst-matchp abnf::cst "designator-list") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "designator-list"))))
Theorem:
(defthm cst-designator-rulename (implies (cst-matchp abnf::cst "designator") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "designator"))))
Theorem:
(defthm cst-static-assert-declaration-rulename (implies (cst-matchp abnf::cst "static-assert-declaration") (equal (abnf::tree-nonleaf->rulename? abnf::cst) (abnf::rulename "static-assert-declaration"))))
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-uppercase-letter-branches-match-alt (implies (cst-matchp abnf::cst "uppercase-letter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x41-5A")))
Theorem:
(defthm cst-lowercase-letter-branches-match-alt (implies (cst-matchp abnf::cst "lowercase-letter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x61-7A")))
Theorem:
(defthm cst-letter-branches-match-alt (implies (cst-matchp abnf::cst "letter") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "uppercase-letter / lowercase-letter")))
Theorem:
(defthm cst-digit-branches-match-alt (implies (cst-matchp abnf::cst "digit") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x30-39")))
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-graphic-character-branches-match-alt (implies (cst-matchp abnf::cst "graphic-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x21-23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E")))
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-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-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-control-character-branches-match-alt (implies (cst-matchp abnf::cst "control-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "horizontal-tab / vertical-tab / form-feed")))
Theorem:
(defthm cst-basic-character-branches-match-alt (implies (cst-matchp abnf::cst "basic-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter / digit / graphic-character / space / control-character")))
Theorem:
(defthm cst-safe-nonascii-branches-match-alt (implies (cst-matchp abnf::cst "safe-nonascii") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x80-2029 / %x202F-2065 / %x206A-D7FF / %xE000-10FFFF")))
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-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-extended-character-branches-match-alt (implies (cst-matchp abnf::cst "extended-character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x24 / %x40 / %x60 / line-feed / carriage-return / safe-nonascii")))
Theorem:
(defthm cst-character-branches-match-alt (implies (cst-matchp abnf::cst "character") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character / extended-character")))
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) "line-feed / carriage-return / carriage-return line-feed")))
Theorem:
(defthm cst-extended-character-not-new-line-branches-match-alt (implies (cst-matchp abnf::cst "extended-character-not-new-line") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x24 / %x40 / %x60 / safe-nonascii")))
Theorem:
(defthm cst-graphic-character-not-star-branches-match-alt (implies (cst-matchp abnf::cst "graphic-character-not-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x21-23 / %x25-29 / %x2B-2F / %x3A-3F / %x5B-5F / %x7B-7E")))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-branches-match-alt (implies (cst-matchp abnf::cst "graphic-character-not-star-or-slash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x21-23 / %x25-29 / %x2B-2E / %x3A-3F / %x5B-5F / %x7B-7E")))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-branches-match-alt (implies (cst-matchp abnf::cst "graphic-character-not-single-quote-or-backslash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x21-23 / %x25-26 / %x28-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-branches-match-alt (implies (cst-matchp abnf::cst "graphic-character-not-double-quote-or-backslash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")))
Theorem:
(defthm cst-basic-character-not-star-branches-match-alt (implies (cst-matchp abnf::cst "basic-character-not-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter / digit / graphic-character-not-star / space / control-character")))
Theorem:
(defthm cst-basic-character-not-star-or-slash-branches-match-alt (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter / digit / graphic-character-not-star-or-slash / space / control-character")))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-branches-match-alt (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter / digit / graphic-character-not-single-quote-or-backslash / space / control-character")))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-branches-match-alt (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter / digit / graphic-character-not-double-quote-or-backslash / space / control-character")))
Theorem:
(defthm cst-character-not-new-line-branches-match-alt (implies (cst-matchp abnf::cst "character-not-new-line") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character / extended-character-not-new-line")))
Theorem:
(defthm cst-character-not-star-branches-match-alt (implies (cst-matchp abnf::cst "character-not-star") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star / extended-character")))
Theorem:
(defthm cst-character-not-star-or-slash-branches-match-alt (implies (cst-matchp abnf::cst "character-not-star-or-slash") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star-or-slash / extended-character")))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-branches-match-alt (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-single-quote-or-backslash / extended-character-not-new-line")))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-branches-match-alt (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-double-quote-or-backslash / extended-character-not-new-line")))
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-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 / character-not-star 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 / character-not-star-or-slash 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) "\"//\" *character-not-new-line")))
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 / string-literal / 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-gcc-keyword-branches-match-alt (implies (cst-matchp abnf::cst "gcc-keyword") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"__alignof__\" / %s\"asm\" / %s\"__asm__\" / %s\"__attribute__\" / %s\"__extension__\" / %s\"__inline\" / %s\"__inline__\" / %s\"__restrict\" / %s\"__restrict__\"")))
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) "\"_\" / letter")))
Theorem:
(defthm cst-universal-character-name-branches-match-alt (implies (cst-matchp abnf::cst "universal-character-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"\\u\" hex-quad / %s\"\\U\" hex-quad hex-quad")))
Theorem:
(defthm cst-hex-quad-branches-match-alt (implies (cst-matchp abnf::cst "hex-quad") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit")))
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 / floating-constant / enumeration-constant / character-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) "%x31-39")))
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) "%x30-37")))
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) "%x30-39 / %x61-66 / %x41-46")))
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-floating-constant-branches-match-alt (implies (cst-matchp abnf::cst "floating-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-constant / hexadecimal-floating-constant")))
Theorem:
(defthm cst-decimal-floating-constant-branches-match-alt (implies (cst-matchp abnf::cst "decimal-floating-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "fractional-constant [ exponent-part ] [ floating-suffix ] / digit-sequence exponent-part [ floating-suffix ]")))
Theorem:
(defthm cst-hexadecimal-floating-constant-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-floating-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ] / hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]")))
Theorem:
(defthm cst-fractional-constant-branches-match-alt (implies (cst-matchp abnf::cst "fractional-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ digit-sequence ] \".\" digit-sequence / digit-sequence \".\"")))
Theorem:
(defthm cst-exponent-part-branches-match-alt (implies (cst-matchp abnf::cst "exponent-part") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"e\" [ sign ] digit-sequence")))
Theorem:
(defthm cst-sign-branches-match-alt (implies (cst-matchp abnf::cst "sign") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"+\" / \"-\"")))
Theorem:
(defthm cst-digit-sequence-branches-match-alt (implies (cst-matchp abnf::cst "digit-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit / digit-sequence digit")))
Theorem:
(defthm cst-hexadecimal-fractional-constant-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-fractional-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence / hexadecimal-digit-sequence \".\"")))
Theorem:
(defthm cst-binary-exponent-part-branches-match-alt (implies (cst-matchp abnf::cst "binary-exponent-part") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"p\" [ sign ] digit-sequence")))
Theorem:
(defthm cst-hexadecimal-digit-sequence-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-digit-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-digit / hexadecimal-digit-sequence hexadecimal-digit")))
Theorem:
(defthm cst-floating-suffix-branches-match-alt (implies (cst-matchp abnf::cst "floating-suffix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%i\"f\" / %i\"l\"")))
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-character-constant-branches-match-alt (implies (cst-matchp abnf::cst "character-constant") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"'\" c-char-sequence \"'\" / %s\"L'\" c-char-sequence \"'\" / %i\"u'\" c-char-sequence \"'\"")))
Theorem:
(defthm cst-c-char-sequence-branches-match-alt (implies (cst-matchp abnf::cst "c-char-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "c-char / c-char-sequence c-char")))
Theorem:
(defthm cst-c-char-branches-match-alt (implies (cst-matchp abnf::cst "c-char") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-single-quote-or-backslash-or-new-line / escape-sequence")))
Theorem:
(defthm cst-escape-sequence-branches-match-alt (implies (cst-matchp abnf::cst "escape-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "simple-escape-sequence / octal-escape-sequence / hexadecimal-escape-sequence / universal-character-name")))
Theorem:
(defthm cst-simple-escape-sequence-branches-match-alt (implies (cst-matchp abnf::cst "simple-escape-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"\\'\" / \"\\\" double-quote / \"\\?\" / \"\\\\\" / %s\"\\a\" / %s\"\\b\" / %s\"\\f\" / %s\"\\n\" / %s\"\\r\" / %s\"\\t\" / %s\"\\v\"")))
Theorem:
(defthm cst-octal-escape-sequence-branches-match-alt (implies (cst-matchp abnf::cst "octal-escape-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" octal-digit octal-digit octal-digit")))
Theorem:
(defthm cst-hexadecimal-escape-sequence-branches-match-alt (implies (cst-matchp abnf::cst "hexadecimal-escape-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"\\x\" hexadecimal-digit / hexadecimal-escape-sequence hexadecimal-digit")))
Theorem:
(defthm cst-string-literal-branches-match-alt (implies (cst-matchp abnf::cst "string-literal") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote")))
Theorem:
(defthm cst-encoding-prefix-branches-match-alt (implies (cst-matchp abnf::cst "encoding-prefix") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"u8\" / %i\"u\" / %s\"L\"")))
Theorem:
(defthm cst-s-char-sequence-branches-match-alt (implies (cst-matchp abnf::cst "s-char-sequence") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "s-char / s-char-sequence s-char")))
Theorem:
(defthm cst-s-char-branches-match-alt (implies (cst-matchp abnf::cst "s-char") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-double-quote-or-backslash-or-new-line / escape-sequence")))
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-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 / 1*string-literal / \"(\" expression \")\" / generic-selection")))
Theorem:
(defthm cst-generic-selection-branches-match-alt (implies (cst-matchp abnf::cst "generic-selection") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\"")))
Theorem:
(defthm cst-generic-assoc-list-branches-match-alt (implies (cst-matchp abnf::cst "generic-assoc-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "generic-association / generic-assoc-list \",\" generic-association")))
Theorem:
(defthm cst-generic-association-branches-match-alt (implies (cst-matchp abnf::cst "generic-association") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-name \":\" assignment-expression / %s\"default\" \":\" assignment-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 \"]\" / postfix-expression \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\" / \"(\" type-name \")\" \"{\" initializer-list \"}\" / \"(\" type-name \")\" \"{\" initializer-list \",\" \"}\"")))
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 / %s\"sizeof\" unary-expression / %s\"sizeof\" \"(\" type-name \")\" / %s\"_Alignof\" \"(\" type-name \")\"")))
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 / expression \",\" 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-attribute-parameters-branches-match-alt (implies (cst-matchp abnf::cst "attribute-parameters") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"(\" [ assignment-expression *( \",\" assignment-expression ) ] \")\"")))
Theorem:
(defthm cst-attribute-branches-match-alt (implies (cst-matchp abnf::cst "attribute") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier [ attribute-parameters ]")))
Theorem:
(defthm cst-attribute-list-branches-match-alt (implies (cst-matchp abnf::cst "attribute-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "attribute *( \",\" attribute )")))
Theorem:
(defthm cst-attribute-specifier-branches-match-alt (implies (cst-matchp abnf::cst "attribute-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"__attribute__\" \"(\" \"(\" [ attribute-list ] \")\" \")\"")))
Theorem:
(defthm cst-asm-name-specifier-branches-match-alt (implies (cst-matchp abnf::cst "asm-name-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "( %s\"asm\" / %s\"__asm__\" ) \"(\" 1*string-literal \")\"")))
Theorem:
(defthm cst-declaration-branches-match-alt (implies (cst-matchp abnf::cst "declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] [ asm-name-specifier ] *attribute-specifier \";\" / static-assert-declaration")))
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 ] / type-qualifier [ declaration-specifiers ] / function-specifier [ declaration-specifiers ] / alignment-specifier [ declaration-specifiers ] / attribute-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 / init-declarator-list \",\" 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\"typedef\" / %s\"extern\" / %s\"static\" / %s\"_Thread_local\" / %s\"auto\" / %s\"register\"")))
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\" / %s\"_Complex\" / atomic-type-specifier / 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) "[ %s\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\" / static-assert-declaration")))
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 ] / type-qualifier [ specifier-qualifier-list ] / alignment-specifier [ specifier-qualifier-list ] / attribute-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 / struct-declarator-list \",\" 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 / [ declarator ] \":\" constant-expression")))
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 ] \"{\" enumerator-list \"}\" / %s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\" / %s\"enum\" identifier")))
Theorem:
(defthm cst-enumerator-list-branches-match-alt (implies (cst-matchp abnf::cst "enumerator-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "enumerator / enumerator-list \",\" enumerator")))
Theorem:
(defthm cst-enumerator-branches-match-alt (implies (cst-matchp abnf::cst "enumerator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "enumeration-constant / enumeration-constant \"=\" constant-expression")))
Theorem:
(defthm cst-atomic-type-specifier-branches-match-alt (implies (cst-matchp abnf::cst "atomic-type-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"_Atomic\" \"(\" type-name \")\"")))
Theorem:
(defthm cst-type-qualifier-branches-match-alt (implies (cst-matchp abnf::cst "type-qualifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"const\" / %s\"restrict\" / %s\"volatile\" / %s\"_Atomic\"")))
Theorem:
(defthm cst-function-specifier-branches-match-alt (implies (cst-matchp abnf::cst "function-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"inline\" / %s\"_Noreturn\"")))
Theorem:
(defthm cst-alignment-specifier-branches-match-alt (implies (cst-matchp abnf::cst "alignment-specifier") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"_Alignas\" \"(\" type-name \")\" / %s\"_Alignas\" \"(\" constant-expression \")\"")))
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 \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\" / direct-declarator \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\" / direct-declarator \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\" / direct-declarator \"[\" [ type-qualifier-list ] \"*\" \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" [ identifier-list ] \")\"")))
Theorem:
(defthm cst-pointer-branches-match-alt (implies (cst-matchp abnf::cst "pointer") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"*\" [ type-qualifier-list ] / \"*\" [ type-qualifier-list ] pointer")))
Theorem:
(defthm cst-type-qualifier-list-branches-match-alt (implies (cst-matchp abnf::cst "type-qualifier-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "type-qualifier / type-qualifier-list type-qualifier")))
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 / 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 / declaration-specifiers [ abstract-declarator ]")))
Theorem:
(defthm cst-identifier-list-branches-match-alt (implies (cst-matchp abnf::cst "identifier-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "identifier / identifier-list \",\" identifier")))
Theorem:
(defthm cst-type-name-branches-match-alt (implies (cst-matchp abnf::cst "type-name") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "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 ] \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\" / [ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" \"*\" \"]\" / [ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\"")))
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) "[ designation ] initializer / initializer-list \",\" [ designation ] initializer")))
Theorem:
(defthm cst-designation-branches-match-alt (implies (cst-matchp abnf::cst "designation") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "designator-list \"=\"")))
Theorem:
(defthm cst-designator-list-branches-match-alt (implies (cst-matchp abnf::cst "designator-list") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "designator / designator-list designator")))
Theorem:
(defthm cst-designator-branches-match-alt (implies (cst-matchp abnf::cst "designator") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"[\" constant-expression \"]\" / \".\" identifier")))
Theorem:
(defthm cst-static-assert-declaration-branches-match-alt (implies (cst-matchp abnf::cst "static-assert-declaration") (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst) "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\"")))
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 / %s\"for\" \"(\" declaration [ 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) "[ %s\"__extension__\" ] declaration-specifiers declarator [ declaration-list ] 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-uppercase-letter-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x41-5A") (or (cst-list-list-conc-matchp abnf::cstss "%x41-5A"))))
Theorem:
(defthm cst-lowercase-letter-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x61-7A") (or (cst-list-list-conc-matchp abnf::cstss "%x61-7A"))))
Theorem:
(defthm cst-letter-concs (implies (cst-list-list-alt-matchp abnf::cstss "uppercase-letter / lowercase-letter") (or (cst-list-list-conc-matchp abnf::cstss "uppercase-letter") (cst-list-list-conc-matchp abnf::cstss "lowercase-letter"))))
Theorem:
(defthm cst-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x30-39") (or (cst-list-list-conc-matchp abnf::cstss "%x30-39"))))
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-graphic-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x21-23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E") (or (cst-list-list-conc-matchp abnf::cstss "%x21-23") (cst-list-list-conc-matchp abnf::cstss "%x25-2F") (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))
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-horizontal-tab-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x9") (or (cst-list-list-conc-matchp abnf::cstss "%x9"))))
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-control-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "horizontal-tab / vertical-tab / form-feed") (or (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"))))
Theorem:
(defthm cst-basic-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "letter / digit / graphic-character / space / control-character") (or (cst-list-list-conc-matchp abnf::cstss "letter") (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "graphic-character") (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "control-character"))))
Theorem:
(defthm cst-safe-nonascii-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x80-2029 / %x202F-2065 / %x206A-D7FF / %xE000-10FFFF") (or (cst-list-list-conc-matchp abnf::cstss "%x80-2029") (cst-list-list-conc-matchp abnf::cstss "%x202F-2065") (cst-list-list-conc-matchp abnf::cstss "%x206A-D7FF") (cst-list-list-conc-matchp abnf::cstss "%xE000-10FFFF"))))
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-carriage-return-concs (implies (cst-list-list-alt-matchp abnf::cstss "%xD") (or (cst-list-list-conc-matchp abnf::cstss "%xD"))))
Theorem:
(defthm cst-extended-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x24 / %x40 / %x60 / line-feed / carriage-return / safe-nonascii") (or (cst-list-list-conc-matchp abnf::cstss "%x24") (cst-list-list-conc-matchp abnf::cstss "%x40") (cst-list-list-conc-matchp abnf::cstss "%x60") (cst-list-list-conc-matchp abnf::cstss "line-feed") (cst-list-list-conc-matchp abnf::cstss "carriage-return") (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))
Theorem:
(defthm cst-character-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character / extended-character") (or (cst-list-list-conc-matchp abnf::cstss "basic-character") (cst-list-list-conc-matchp abnf::cstss "extended-character"))))
Theorem:
(defthm cst-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "line-feed / carriage-return / carriage-return line-feed") (or (cst-list-list-conc-matchp abnf::cstss "line-feed") (cst-list-list-conc-matchp abnf::cstss "carriage-return") (cst-list-list-conc-matchp abnf::cstss "carriage-return line-feed"))))
Theorem:
(defthm cst-extended-character-not-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x24 / %x40 / %x60 / safe-nonascii") (or (cst-list-list-conc-matchp abnf::cstss "%x24") (cst-list-list-conc-matchp abnf::cstss "%x40") (cst-list-list-conc-matchp abnf::cstss "%x60") (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))
Theorem:
(defthm cst-graphic-character-not-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x21-23 / %x25-29 / %x2B-2F / %x3A-3F / %x5B-5F / %x7B-7E") (or (cst-list-list-conc-matchp abnf::cstss "%x21-23") (cst-list-list-conc-matchp abnf::cstss "%x25-29") (cst-list-list-conc-matchp abnf::cstss "%x2B-2F") (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x21-23 / %x25-29 / %x2B-2E / %x3A-3F / %x5B-5F / %x7B-7E") (or (cst-list-list-conc-matchp abnf::cstss "%x21-23") (cst-list-list-conc-matchp abnf::cstss "%x25-29") (cst-list-list-conc-matchp abnf::cstss "%x2B-2E") (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x21-23 / %x25-26 / %x28-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E") (or (cst-list-list-conc-matchp abnf::cstss "%x21-23") (cst-list-list-conc-matchp abnf::cstss "%x25-26") (cst-list-list-conc-matchp abnf::cstss "%x28-2F") (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (cst-list-list-conc-matchp abnf::cstss "%x5B") (cst-list-list-conc-matchp abnf::cstss "%x5D-5F") (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E") (or (cst-list-list-conc-matchp abnf::cstss "%x21") (cst-list-list-conc-matchp abnf::cstss "%x23") (cst-list-list-conc-matchp abnf::cstss "%x25-2F") (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (cst-list-list-conc-matchp abnf::cstss "%x5B") (cst-list-list-conc-matchp abnf::cstss "%x5D-5F") (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))
Theorem:
(defthm cst-basic-character-not-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "letter / digit / graphic-character-not-star / space / control-character") (or (cst-list-list-conc-matchp abnf::cstss "letter") (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star") (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "control-character"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-concs (implies (cst-list-list-alt-matchp abnf::cstss "letter / digit / graphic-character-not-star-or-slash / space / control-character") (or (cst-list-list-conc-matchp abnf::cstss "letter") (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star-or-slash") (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "control-character"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-concs (implies (cst-list-list-alt-matchp abnf::cstss "letter / digit / graphic-character-not-single-quote-or-backslash / space / control-character") (or (cst-list-list-conc-matchp abnf::cstss "letter") (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-single-quote-or-backslash") (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "control-character"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-concs (implies (cst-list-list-alt-matchp abnf::cstss "letter / digit / graphic-character-not-double-quote-or-backslash / space / control-character") (or (cst-list-list-conc-matchp abnf::cstss "letter") (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-double-quote-or-backslash") (cst-list-list-conc-matchp abnf::cstss "space") (cst-list-list-conc-matchp abnf::cstss "control-character"))))
Theorem:
(defthm cst-character-not-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character / extended-character-not-new-line") (or (cst-list-list-conc-matchp abnf::cstss "basic-character") (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-star-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character-not-star / extended-character") (or (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star") (cst-list-list-conc-matchp abnf::cstss "extended-character"))))
Theorem:
(defthm cst-character-not-star-or-slash-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character-not-star-or-slash / extended-character") (or (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star-or-slash") (cst-list-list-conc-matchp abnf::cstss "extended-character"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character-not-single-quote-or-backslash / extended-character-not-new-line") (or (cst-list-list-conc-matchp abnf::cstss "basic-character-not-single-quote-or-backslash") (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-concs (implies (cst-list-list-alt-matchp abnf::cstss "basic-character-not-double-quote-or-backslash / extended-character-not-new-line") (or (cst-list-list-conc-matchp abnf::cstss "basic-character-not-double-quote-or-backslash") (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))))
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-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 / character-not-star 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 "character-not-star 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 / character-not-star-or-slash 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 "character-not-star-or-slash rest-of-block-comment"))))
Theorem:
(defthm cst-line-comment-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"//\" *character-not-new-line") (or (cst-list-list-conc-matchp abnf::cstss "\"//\" *character-not-new-line"))))
Theorem:
(defthm cst-token-concs (implies (cst-list-list-alt-matchp abnf::cstss "keyword / identifier / constant / string-literal / 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 "string-literal") (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-gcc-keyword-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"__alignof__\" / %s\"asm\" / %s\"__asm__\" / %s\"__attribute__\" / %s\"__extension__\" / %s\"__inline\" / %s\"__inline__\" / %s\"__restrict\" / %s\"__restrict__\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"__alignof__\"") (cst-list-list-conc-matchp abnf::cstss "%s\"asm\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__asm__\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__extension__\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__inline\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__inline__\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict\"") (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict__\""))))
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 "\"_\" / letter") (or (cst-list-list-conc-matchp abnf::cstss "\"_\"") (cst-list-list-conc-matchp abnf::cstss "letter"))))
Theorem:
(defthm cst-universal-character-name-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\u\" hex-quad / %s\"\\U\" hex-quad hex-quad") (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\u\" hex-quad") (cst-list-list-conc-matchp abnf::cstss "%s\"\\U\" hex-quad hex-quad"))))
Theorem:
(defthm cst-hex-quad-concs (implies (cst-list-list-alt-matchp abnf::cstss "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit") (or (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit"))))
Theorem:
(defthm cst-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "integer-constant / floating-constant / enumeration-constant / character-constant") (or (cst-list-list-conc-matchp abnf::cstss "integer-constant") (cst-list-list-conc-matchp abnf::cstss "floating-constant") (cst-list-list-conc-matchp abnf::cstss "enumeration-constant") (cst-list-list-conc-matchp abnf::cstss "character-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 "%x31-39") (or (cst-list-list-conc-matchp abnf::cstss "%x31-39"))))
Theorem:
(defthm cst-octal-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x30-37") (or (cst-list-list-conc-matchp abnf::cstss "%x30-37"))))
Theorem:
(defthm cst-hexadecimal-digit-concs (implies (cst-list-list-alt-matchp abnf::cstss "%x30-39 / %x61-66 / %x41-46") (or (cst-list-list-conc-matchp abnf::cstss "%x30-39") (cst-list-list-conc-matchp abnf::cstss "%x61-66") (cst-list-list-conc-matchp abnf::cstss "%x41-46"))))
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-floating-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "decimal-floating-constant / hexadecimal-floating-constant") (or (cst-list-list-conc-matchp abnf::cstss "decimal-floating-constant") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-constant"))))
Theorem:
(defthm cst-decimal-floating-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "fractional-constant [ exponent-part ] [ floating-suffix ] / digit-sequence exponent-part [ floating-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "fractional-constant [ exponent-part ] [ floating-suffix ]") (cst-list-list-conc-matchp abnf::cstss "digit-sequence exponent-part [ floating-suffix ]"))))
Theorem:
(defthm cst-hexadecimal-floating-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ] / hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]") (or (cst-list-list-conc-matchp abnf::cstss "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ]") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]"))))
Theorem:
(defthm cst-fractional-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ digit-sequence ] \".\" digit-sequence / digit-sequence \".\"") (or (cst-list-list-conc-matchp abnf::cstss "[ digit-sequence ] \".\" digit-sequence") (cst-list-list-conc-matchp abnf::cstss "digit-sequence \".\""))))
Theorem:
(defthm cst-exponent-part-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"e\" [ sign ] digit-sequence") (or (cst-list-list-conc-matchp abnf::cstss "%i\"e\" [ sign ] digit-sequence"))))
Theorem:
(defthm cst-sign-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"+\" / \"-\"") (or (cst-list-list-conc-matchp abnf::cstss "\"+\"") (cst-list-list-conc-matchp abnf::cstss "\"-\""))))
Theorem:
(defthm cst-digit-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "digit / digit-sequence digit") (or (cst-list-list-conc-matchp abnf::cstss "digit") (cst-list-list-conc-matchp abnf::cstss "digit-sequence digit"))))
Theorem:
(defthm cst-hexadecimal-fractional-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence / hexadecimal-digit-sequence \".\"") (or (cst-list-list-conc-matchp abnf::cstss "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit-sequence \".\""))))
Theorem:
(defthm cst-binary-exponent-part-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"p\" [ sign ] digit-sequence") (or (cst-list-list-conc-matchp abnf::cstss "%i\"p\" [ sign ] digit-sequence"))))
Theorem:
(defthm cst-hexadecimal-digit-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "hexadecimal-digit / hexadecimal-digit-sequence hexadecimal-digit") (or (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit-sequence hexadecimal-digit"))))
Theorem:
(defthm cst-floating-suffix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%i\"f\" / %i\"l\"") (or (cst-list-list-conc-matchp abnf::cstss "%i\"f\"") (cst-list-list-conc-matchp abnf::cstss "%i\"l\""))))
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-character-constant-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"'\" c-char-sequence \"'\" / %s\"L'\" c-char-sequence \"'\" / %i\"u'\" c-char-sequence \"'\"") (or (cst-list-list-conc-matchp abnf::cstss "\"'\" c-char-sequence \"'\"") (cst-list-list-conc-matchp abnf::cstss "%s\"L'\" c-char-sequence \"'\"") (cst-list-list-conc-matchp abnf::cstss "%i\"u'\" c-char-sequence \"'\""))))
Theorem:
(defthm cst-c-char-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "c-char / c-char-sequence c-char") (or (cst-list-list-conc-matchp abnf::cstss "c-char") (cst-list-list-conc-matchp abnf::cstss "c-char-sequence c-char"))))
Theorem:
(defthm cst-c-char-concs (implies (cst-list-list-alt-matchp abnf::cstss "character-not-single-quote-or-backslash-or-new-line / escape-sequence") (or (cst-list-list-conc-matchp abnf::cstss "character-not-single-quote-or-backslash-or-new-line") (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "simple-escape-sequence / octal-escape-sequence / hexadecimal-escape-sequence / universal-character-name") (or (cst-list-list-conc-matchp abnf::cstss "simple-escape-sequence") (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-escape-sequence") (cst-list-list-conc-matchp abnf::cstss "universal-character-name"))))
Theorem:
(defthm cst-simple-escape-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"\\'\" / \"\\\" double-quote / \"\\?\" / \"\\\\\" / %s\"\\a\" / %s\"\\b\" / %s\"\\f\" / %s\"\\n\" / %s\"\\r\" / %s\"\\t\" / %s\"\\v\"") (or (cst-list-list-conc-matchp abnf::cstss "\"\\'\"") (cst-list-list-conc-matchp abnf::cstss "\"\\\" double-quote") (cst-list-list-conc-matchp abnf::cstss "\"\\?\"") (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\a\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"") (cst-list-list-conc-matchp abnf::cstss "%s\"\\v\""))))
Theorem:
(defthm cst-octal-escape-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" octal-digit octal-digit octal-digit") (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit") (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit octal-digit") (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit octal-digit octal-digit"))))
Theorem:
(defthm cst-hexadecimal-escape-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\x\" hexadecimal-digit / hexadecimal-escape-sequence hexadecimal-digit") (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\x\" hexadecimal-digit") (cst-list-list-conc-matchp abnf::cstss "hexadecimal-escape-sequence hexadecimal-digit"))))
Theorem:
(defthm cst-string-literal-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote") (or (cst-list-list-conc-matchp abnf::cstss "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote"))))
Theorem:
(defthm cst-encoding-prefix-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"u8\" / %i\"u\" / %s\"L\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"") (cst-list-list-conc-matchp abnf::cstss "%i\"u\"") (cst-list-list-conc-matchp abnf::cstss "%s\"L\""))))
Theorem:
(defthm cst-s-char-sequence-concs (implies (cst-list-list-alt-matchp abnf::cstss "s-char / s-char-sequence s-char") (or (cst-list-list-conc-matchp abnf::cstss "s-char") (cst-list-list-conc-matchp abnf::cstss "s-char-sequence s-char"))))
Theorem:
(defthm cst-s-char-concs (implies (cst-list-list-alt-matchp abnf::cstss "character-not-double-quote-or-backslash-or-new-line / escape-sequence") (or (cst-list-list-conc-matchp abnf::cstss "character-not-double-quote-or-backslash-or-new-line") (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))
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-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 / 1*string-literal / \"(\" expression \")\" / generic-selection") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "constant") (cst-list-list-conc-matchp abnf::cstss "1*string-literal") (cst-list-list-conc-matchp abnf::cstss "\"(\" expression \")\"") (cst-list-list-conc-matchp abnf::cstss "generic-selection"))))
Theorem:
(defthm cst-generic-selection-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\""))))
Theorem:
(defthm cst-generic-assoc-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "generic-association / generic-assoc-list \",\" generic-association") (or (cst-list-list-conc-matchp abnf::cstss "generic-association") (cst-list-list-conc-matchp abnf::cstss "generic-assoc-list \",\" generic-association"))))
Theorem:
(defthm cst-generic-association-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-name \":\" assignment-expression / %s\"default\" \":\" assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "type-name \":\" assignment-expression") (cst-list-list-conc-matchp abnf::cstss "%s\"default\" \":\" assignment-expression"))))
Theorem:
(defthm cst-postfix-expression-concs (implies (cst-list-list-alt-matchp abnf::cstss "primary-expression / postfix-expression \"[\" expression \"]\" / postfix-expression \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\" / \"(\" type-name \")\" \"{\" initializer-list \"}\" / \"(\" type-name \")\" \"{\" initializer-list \",\" \"}\"") (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 "postfix-expression \"(\" [ 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 \"--\"") (cst-list-list-conc-matchp abnf::cstss "\"(\" type-name \")\" \"{\" initializer-list \"}\"") (cst-list-list-conc-matchp abnf::cstss "\"(\" type-name \")\" \"{\" initializer-list \",\" \"}\""))))
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 / %s\"sizeof\" unary-expression / %s\"sizeof\" \"(\" type-name \")\" / %s\"_Alignof\" \"(\" type-name \")\"") (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") (cst-list-list-conc-matchp abnf::cstss "%s\"sizeof\" unary-expression") (cst-list-list-conc-matchp abnf::cstss "%s\"sizeof\" \"(\" type-name \")\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignof\" \"(\" type-name \")\""))))
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 / expression \",\" assignment-expression") (or (cst-list-list-conc-matchp abnf::cstss "assignment-expression") (cst-list-list-conc-matchp abnf::cstss "expression \",\" 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-attribute-parameters-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"(\" [ assignment-expression *( \",\" assignment-expression ) ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" [ assignment-expression *( \",\" assignment-expression ) ] \")\""))))
Theorem:
(defthm cst-attribute-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier [ attribute-parameters ]") (or (cst-list-list-conc-matchp abnf::cstss "identifier [ attribute-parameters ]"))))
Theorem:
(defthm cst-attribute-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "attribute *( \",\" attribute )") (or (cst-list-list-conc-matchp abnf::cstss "attribute *( \",\" attribute )"))))
Theorem:
(defthm cst-attribute-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"__attribute__\" \"(\" \"(\" [ attribute-list ] \")\" \")\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\" \"(\" \"(\" [ attribute-list ] \")\" \")\""))))
Theorem:
(defthm cst-asm-name-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "( %s\"asm\" / %s\"__asm__\" ) \"(\" 1*string-literal \")\"") (or (cst-list-list-conc-matchp abnf::cstss "( %s\"asm\" / %s\"__asm__\" ) \"(\" 1*string-literal \")\""))))
Theorem:
(defthm cst-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] [ asm-name-specifier ] *attribute-specifier \";\" / static-assert-declaration") (or (cst-list-list-conc-matchp abnf::cstss "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] [ asm-name-specifier ] *attribute-specifier \";\"") (cst-list-list-conc-matchp abnf::cstss "static-assert-declaration"))))
Theorem:
(defthm cst-declaration-specifiers-concs (implies (cst-list-list-alt-matchp abnf::cstss "storage-class-specifier [ declaration-specifiers ] / type-specifier [ declaration-specifiers ] / type-qualifier [ declaration-specifiers ] / function-specifier [ declaration-specifiers ] / alignment-specifier [ declaration-specifiers ] / attribute-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 ]") (cst-list-list-conc-matchp abnf::cstss "type-qualifier [ declaration-specifiers ]") (cst-list-list-conc-matchp abnf::cstss "function-specifier [ declaration-specifiers ]") (cst-list-list-conc-matchp abnf::cstss "alignment-specifier [ declaration-specifiers ]") (cst-list-list-conc-matchp abnf::cstss "attribute-specifier [ declaration-specifiers ]"))))
Theorem:
(defthm cst-init-declarator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "init-declarator / init-declarator-list \",\" init-declarator") (or (cst-list-list-conc-matchp abnf::cstss "init-declarator") (cst-list-list-conc-matchp abnf::cstss "init-declarator-list \",\" 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\"typedef\" / %s\"extern\" / %s\"static\" / %s\"_Thread_local\" / %s\"auto\" / %s\"register\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"") (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"") (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\"") (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"") (cst-list-list-conc-matchp abnf::cstss "%s\"register\""))))
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\" / %s\"_Complex\" / atomic-type-specifier / 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 "%s\"_Complex\"") (cst-list-list-conc-matchp abnf::cstss "atomic-type-specifier") (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 "[ %s\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\" / static-assert-declaration") (or (cst-list-list-conc-matchp abnf::cstss "[ %s\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\"") (cst-list-list-conc-matchp abnf::cstss "static-assert-declaration"))))
Theorem:
(defthm cst-specifier-qualifier-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-specifier [ specifier-qualifier-list ] / type-qualifier [ specifier-qualifier-list ] / alignment-specifier [ specifier-qualifier-list ] / attribute-specifier [ specifier-qualifier-list ]") (or (cst-list-list-conc-matchp abnf::cstss "type-specifier [ specifier-qualifier-list ]") (cst-list-list-conc-matchp abnf::cstss "type-qualifier [ specifier-qualifier-list ]") (cst-list-list-conc-matchp abnf::cstss "alignment-specifier [ specifier-qualifier-list ]") (cst-list-list-conc-matchp abnf::cstss "attribute-specifier [ specifier-qualifier-list ]"))))
Theorem:
(defthm cst-struct-declarator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "struct-declarator / struct-declarator-list \",\" struct-declarator") (or (cst-list-list-conc-matchp abnf::cstss "struct-declarator") (cst-list-list-conc-matchp abnf::cstss "struct-declarator-list \",\" struct-declarator"))))
Theorem:
(defthm cst-struct-declarator-concs (implies (cst-list-list-alt-matchp abnf::cstss "declarator / [ declarator ] \":\" constant-expression") (or (cst-list-list-conc-matchp abnf::cstss "declarator") (cst-list-list-conc-matchp abnf::cstss "[ declarator ] \":\" constant-expression"))))
Theorem:
(defthm cst-enum-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"enum\" [ identifier ] \"{\" enumerator-list \"}\" / %s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\" / %s\"enum\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" [ identifier ] \"{\" enumerator-list \"}\"") (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\"") (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" identifier"))))
Theorem:
(defthm cst-enumerator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "enumerator / enumerator-list \",\" enumerator") (or (cst-list-list-conc-matchp abnf::cstss "enumerator") (cst-list-list-conc-matchp abnf::cstss "enumerator-list \",\" enumerator"))))
Theorem:
(defthm cst-enumerator-concs (implies (cst-list-list-alt-matchp abnf::cstss "enumeration-constant / enumeration-constant \"=\" constant-expression") (or (cst-list-list-conc-matchp abnf::cstss "enumeration-constant") (cst-list-list-conc-matchp abnf::cstss "enumeration-constant \"=\" constant-expression"))))
Theorem:
(defthm cst-atomic-type-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"_Atomic\" \"(\" type-name \")\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\" \"(\" type-name \")\""))))
Theorem:
(defthm cst-type-qualifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"const\" / %s\"restrict\" / %s\"volatile\" / %s\"_Atomic\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"const\"") (cst-list-list-conc-matchp abnf::cstss "%s\"restrict\"") (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\""))))
Theorem:
(defthm cst-function-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"inline\" / %s\"_Noreturn\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\""))))
Theorem:
(defthm cst-alignment-specifier-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"_Alignas\" \"(\" type-name \")\" / %s\"_Alignas\" \"(\" constant-expression \")\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignas\" \"(\" type-name \")\"") (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignas\" \"(\" constant-expression \")\""))))
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 \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\" / direct-declarator \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\" / direct-declarator \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\" / direct-declarator \"[\" [ type-qualifier-list ] \"*\" \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" [ identifier-list ] \")\"") (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 \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"[\" [ type-qualifier-list ] \"*\" \"]\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"(\" parameter-type-list \")\"") (cst-list-list-conc-matchp abnf::cstss "direct-declarator \"(\" [ identifier-list ] \")\""))))
Theorem:
(defthm cst-pointer-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"*\" [ type-qualifier-list ] / \"*\" [ type-qualifier-list ] pointer") (or (cst-list-list-conc-matchp abnf::cstss "\"*\" [ type-qualifier-list ]") (cst-list-list-conc-matchp abnf::cstss "\"*\" [ type-qualifier-list ] pointer"))))
Theorem:
(defthm cst-type-qualifier-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "type-qualifier / type-qualifier-list type-qualifier") (or (cst-list-list-conc-matchp abnf::cstss "type-qualifier") (cst-list-list-conc-matchp abnf::cstss "type-qualifier-list type-qualifier"))))
Theorem:
(defthm cst-parameter-type-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "parameter-list / parameter-list \",\" \"...\"") (or (cst-list-list-conc-matchp abnf::cstss "parameter-list") (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 / declaration-specifiers [ abstract-declarator ]") (or (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers declarator") (cst-list-list-conc-matchp abnf::cstss "declaration-specifiers [ abstract-declarator ]"))))
Theorem:
(defthm cst-identifier-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "identifier / identifier-list \",\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "identifier") (cst-list-list-conc-matchp abnf::cstss "identifier-list \",\" identifier"))))
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 ] \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\" / [ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" \"*\" \"]\" / [ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\"") (or (cst-list-list-conc-matchp abnf::cstss "\"(\" abstract-declarator \")\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"[\" [ type-qualifier-list ] [ assignment-expression ] \"]\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-list ] assignment-expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"[\" type-qualifier-list %s\"static\" assignment-expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"[\" \"*\" \"]\"") (cst-list-list-conc-matchp abnf::cstss "[ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\""))))
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 "[ designation ] initializer / initializer-list \",\" [ designation ] initializer") (or (cst-list-list-conc-matchp abnf::cstss "[ designation ] initializer") (cst-list-list-conc-matchp abnf::cstss "initializer-list \",\" [ designation ] initializer"))))
Theorem:
(defthm cst-designation-concs (implies (cst-list-list-alt-matchp abnf::cstss "designator-list \"=\"") (or (cst-list-list-conc-matchp abnf::cstss "designator-list \"=\""))))
Theorem:
(defthm cst-designator-list-concs (implies (cst-list-list-alt-matchp abnf::cstss "designator / designator-list designator") (or (cst-list-list-conc-matchp abnf::cstss "designator") (cst-list-list-conc-matchp abnf::cstss "designator-list designator"))))
Theorem:
(defthm cst-designator-concs (implies (cst-list-list-alt-matchp abnf::cstss "\"[\" constant-expression \"]\" / \".\" identifier") (or (cst-list-list-conc-matchp abnf::cstss "\"[\" constant-expression \"]\"") (cst-list-list-conc-matchp abnf::cstss "\".\" identifier"))))
Theorem:
(defthm cst-static-assert-declaration-concs (implies (cst-list-list-alt-matchp abnf::cstss "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\"") (or (cst-list-list-conc-matchp abnf::cstss "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\""))))
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 / %s\"for\" \"(\" declaration [ 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") (cst-list-list-conc-matchp abnf::cstss "%s\"for\" \"(\" declaration [ 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 "[ %s\"__extension__\" ] declaration-specifiers declarator [ declaration-list ] compound-statement") (or (cst-list-list-conc-matchp abnf::cstss "[ %s\"__extension__\" ] declaration-specifiers declarator [ declaration-list ] 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-uppercase-letter-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x41-5A") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x41-5A"))))
Theorem:
(defthm cst-lowercase-letter-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x61-7A") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x61-7A"))))
Theorem:
(defthm cst-letter-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "uppercase-letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "uppercase-letter"))))
Theorem:
(defthm cst-letter-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "lowercase-letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "lowercase-letter"))))
Theorem:
(defthm cst-digit-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x30-39") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x30-39"))))
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-graphic-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x25-2F"))))
Theorem:
(defthm cst-graphic-character-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x7B-7E"))))
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-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-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-control-character-conc1-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-control-character-conc2-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-control-character-conc3-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-basic-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
Theorem:
(defthm cst-basic-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-basic-character-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "graphic-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "graphic-character"))))
Theorem:
(defthm cst-basic-character-conc4-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-basic-character-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "control-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "control-character"))))
Theorem:
(defthm cst-safe-nonascii-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x80-2029") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x80-2029"))))
Theorem:
(defthm cst-safe-nonascii-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x202F-2065") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x202F-2065"))))
Theorem:
(defthm cst-safe-nonascii-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x206A-D7FF") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x206A-D7FF"))))
Theorem:
(defthm cst-safe-nonascii-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%xE000-10FFFF") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%xE000-10FFFF"))))
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-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-extended-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x24") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x24"))))
Theorem:
(defthm cst-extended-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x40") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x40"))))
Theorem:
(defthm cst-extended-character-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x60") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x60"))))
Theorem:
(defthm cst-extended-character-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-feed") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-feed"))))
Theorem:
(defthm cst-extended-character-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "carriage-return") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "carriage-return"))))
Theorem:
(defthm cst-extended-character-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "safe-nonascii"))))
Theorem:
(defthm cst-character-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character"))))
Theorem:
(defthm cst-character-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character"))))
Theorem:
(defthm cst-new-line-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "line-feed") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "line-feed"))))
Theorem:
(defthm cst-new-line-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "carriage-return") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "carriage-return"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x24") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x24"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x40") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x40"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x60") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x60"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "safe-nonascii"))))
Theorem:
(defthm cst-graphic-character-not-star-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-star-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x25-29") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x25-29"))))
Theorem:
(defthm cst-graphic-character-not-star-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-2F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x2B-2F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x25-29") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x25-29"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc3-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-graphic-character-not-star-or-slash-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x25-26") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x25-26"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x28-2F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x28-2F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5B") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5B"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5D-5F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5D-5F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x21") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x21"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x23") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x23"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x25-2F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5B") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5B"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x5D-5F") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x5D-5F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x7B-7E"))))
Theorem:
(defthm cst-basic-character-not-star-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "graphic-character-not-star"))))
Theorem:
(defthm cst-basic-character-not-star-conc4-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-basic-character-not-star-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "control-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "control-character"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star-or-slash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "graphic-character-not-star-or-slash"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-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-basic-character-not-star-or-slash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "control-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "control-character"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-single-quote-or-backslash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "graphic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-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-basic-character-not-single-quote-or-backslash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "control-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "control-character"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-double-quote-or-backslash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "graphic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-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-basic-character-not-double-quote-or-backslash-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "control-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "control-character"))))
Theorem:
(defthm cst-character-not-new-line-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character"))))
Theorem:
(defthm cst-character-not-new-line-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-star-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character-not-star"))))
Theorem:
(defthm cst-character-not-star-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character"))))
Theorem:
(defthm cst-character-not-star-or-slash-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star-or-slash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character-not-star-or-slash"))))
Theorem:
(defthm cst-character-not-star-or-slash-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character-not-single-quote-or-backslash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "basic-character-not-double-quote-or-backslash") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "basic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "extended-character-not-new-line"))))
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-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-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 "string-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "string-literal"))))
Theorem:
(defthm cst-token-conc5-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-gcc-keyword-conc1-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-gcc-keyword-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"asm\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"asm\""))))
Theorem:
(defthm cst-gcc-keyword-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__asm__\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"__asm__\""))))
Theorem:
(defthm cst-gcc-keyword-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"__attribute__\""))))
Theorem:
(defthm cst-gcc-keyword-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__extension__\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"__extension__\""))))
Theorem:
(defthm cst-gcc-keyword-conc6-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-gcc-keyword-conc7-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-gcc-keyword-conc8-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-gcc-keyword-conc9-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-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 "letter") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "letter"))))
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 "floating-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "floating-constant"))))
Theorem:
(defthm cst-constant-conc3-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-constant-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "character-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "character-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-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x31-39") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x31-39"))))
Theorem:
(defthm cst-octal-digit-conc-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x30-37") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x30-37"))))
Theorem:
(defthm cst-hexadecimal-digit-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x30-39") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x30-39"))))
Theorem:
(defthm cst-hexadecimal-digit-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x61-66") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x61-66"))))
Theorem:
(defthm cst-hexadecimal-digit-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%x41-46") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%x41-46"))))
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-floating-constant-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "decimal-floating-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "decimal-floating-constant"))))
Theorem:
(defthm cst-floating-constant-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-constant") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hexadecimal-floating-constant"))))
Theorem:
(defthm cst-sign-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"+\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"+\""))))
Theorem:
(defthm cst-sign-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "\"-\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "\"-\""))))
Theorem:
(defthm cst-digit-sequence-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "digit"))))
Theorem:
(defthm cst-hexadecimal-digit-sequence-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hexadecimal-digit"))))
Theorem:
(defthm cst-floating-suffix-conc1-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-floating-suffix-conc2-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-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-c-char-sequence-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "c-char") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "c-char"))))
Theorem:
(defthm cst-c-char-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "character-not-single-quote-or-backslash-or-new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "character-not-single-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-c-char-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "simple-escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "simple-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "octal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "hexadecimal-escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "hexadecimal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc4-matching (implies (cst-list-list-conc-matchp abnf::cstss "universal-character-name") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "universal-character-name"))))
Theorem:
(defthm cst-simple-escape-sequence-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-simple-escape-sequence-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-simple-escape-sequence-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-simple-escape-sequence-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\a\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\a\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc6-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\b\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc7-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\f\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc8-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\n\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc9-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\r\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc10-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\t\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc11-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\v\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"\\v\""))))
Theorem:
(defthm cst-encoding-prefix-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"u8\""))))
Theorem:
(defthm cst-encoding-prefix-conc2-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-encoding-prefix-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"L\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"L\""))))
Theorem:
(defthm cst-s-char-sequence-conc1-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-s-char-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "character-not-double-quote-or-backslash-or-new-line") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "character-not-double-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-s-char-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "escape-sequence"))))
Theorem:
(defthm cst-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-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-primary-expression-conc2-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-primary-expression-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "1*string-literal") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "1*string-literal"))))
Theorem:
(defthm cst-primary-expression-conc5-matching (implies (cst-list-list-conc-matchp abnf::cstss "generic-selection") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "generic-selection"))))
Theorem:
(defthm cst-generic-assoc-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "generic-association") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "generic-association"))))
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-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-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-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "static-assert-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "static-assert-declaration"))))
Theorem:
(defthm cst-init-declarator-list-conc1-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-conc1-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-storage-class-specifier-conc2-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-storage-class-specifier-conc3-matching (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"static\""))))
Theorem:
(defthm cst-storage-class-specifier-conc4-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-storage-class-specifier-conc5-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-storage-class-specifier-conc6-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-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 "%s\"_Complex\"") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "%s\"_Complex\""))))
Theorem:
(defthm cst-type-specifier-conc12-matching (implies (cst-list-list-conc-matchp abnf::cstss "atomic-type-specifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "atomic-type-specifier"))))
Theorem:
(defthm cst-type-specifier-conc13-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-conc14-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-conc15-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-declaration-conc2-matching (implies (cst-list-list-conc-matchp abnf::cstss "static-assert-declaration") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "static-assert-declaration"))))
Theorem:
(defthm cst-struct-declarator-list-conc1-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-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-enumerator-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "enumerator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "enumerator"))))
Theorem:
(defthm cst-enumerator-conc1-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-type-qualifier-conc1-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-type-qualifier-conc2-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-type-qualifier-conc3-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-type-qualifier-conc4-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-function-specifier-conc1-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-function-specifier-conc2-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-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-type-qualifier-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "type-qualifier") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "type-qualifier"))))
Theorem:
(defthm cst-parameter-type-list-conc1-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-identifier-list-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-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-designator-list-conc1-matching (implies (cst-list-list-conc-matchp abnf::cstss "designator") (and (equal (len abnf::cstss) 1) (cst-list-rep-matchp (nth 0 abnf::cstss) "designator"))))
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-uppercase-letter-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x41-5A") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x41-5A"))))
Theorem:
(defthm cst-lowercase-letter-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x61-7A") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x61-7A"))))
Theorem:
(defthm cst-letter-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "uppercase-letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "uppercase-letter"))))
Theorem:
(defthm cst-letter-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "lowercase-letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "lowercase-letter"))))
Theorem:
(defthm cst-digit-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x30-39") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x30-39"))))
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-graphic-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x21-23") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x25-2F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x25-2F"))))
Theorem:
(defthm cst-graphic-character-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x3A-3F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5B-5F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x7B-7E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x7B-7E"))))
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-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-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-control-character-conc1-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-control-character-conc2-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-control-character-conc3-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-basic-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
Theorem:
(defthm cst-basic-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-basic-character-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "graphic-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "graphic-character"))))
Theorem:
(defthm cst-basic-character-conc4-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-basic-character-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "control-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "control-character"))))
Theorem:
(defthm cst-safe-nonascii-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x80-2029") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x80-2029"))))
Theorem:
(defthm cst-safe-nonascii-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x202F-2065") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x202F-2065"))))
Theorem:
(defthm cst-safe-nonascii-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x206A-D7FF") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x206A-D7FF"))))
Theorem:
(defthm cst-safe-nonascii-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%xE000-10FFFF") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%xE000-10FFFF"))))
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-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-extended-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x24") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x24"))))
Theorem:
(defthm cst-extended-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x40") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x40"))))
Theorem:
(defthm cst-extended-character-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x60") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x60"))))
Theorem:
(defthm cst-extended-character-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-feed") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-feed"))))
Theorem:
(defthm cst-extended-character-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "carriage-return") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "carriage-return"))))
Theorem:
(defthm cst-extended-character-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "safe-nonascii") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "safe-nonascii"))))
Theorem:
(defthm cst-character-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character"))))
Theorem:
(defthm cst-character-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character"))))
Theorem:
(defthm cst-new-line-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "line-feed") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "line-feed"))))
Theorem:
(defthm cst-new-line-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "carriage-return") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "carriage-return"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x24") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x24"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x40") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x40"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x60") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x60"))))
Theorem:
(defthm cst-extended-character-not-new-line-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "safe-nonascii") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "safe-nonascii"))))
Theorem:
(defthm cst-graphic-character-not-star-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x21-23") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-star-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x25-29") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x25-29"))))
Theorem:
(defthm cst-graphic-character-not-star-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x2B-2F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x2B-2F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x3A-3F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5B-5F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-not-star-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x7B-7E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x21-23") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x25-29") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x25-29"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc3-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-graphic-character-not-star-or-slash-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x3A-3F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5B-5F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5B-5F"))))
Theorem:
(defthm cst-graphic-character-not-star-or-slash-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x7B-7E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x21-23") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x21-23"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x25-26") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x25-26"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x28-2F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x28-2F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x3A-3F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5B") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5B"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5D-5F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5D-5F"))))
Theorem:
(defthm cst-graphic-character-not-single-quote-or-backslash-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x7B-7E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x7B-7E"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x21") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x21"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x23") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x23"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x25-2F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x25-2F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x3A-3F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x3A-3F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5B") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5B"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x5D-5F") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x5D-5F"))))
Theorem:
(defthm cst-graphic-character-not-double-quote-or-backslash-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x7B-7E") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x7B-7E"))))
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "graphic-character-not-star") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "graphic-character-not-star"))))
Theorem:
(defthm cst-basic-character-not-star-conc4-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-basic-character-not-star-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "control-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "control-character"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "graphic-character-not-star-or-slash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "graphic-character-not-star-or-slash"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-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-basic-character-not-star-or-slash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "control-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "control-character"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "graphic-character-not-single-quote-or-backslash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "graphic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-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-basic-character-not-single-quote-or-backslash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "control-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "control-character"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "graphic-character-not-double-quote-or-backslash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "graphic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-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-basic-character-not-double-quote-or-backslash-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "control-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "control-character"))))
Theorem:
(defthm cst-character-not-new-line-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character"))))
Theorem:
(defthm cst-character-not-new-line-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character-not-new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-star-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character-not-star") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character-not-star"))))
Theorem:
(defthm cst-character-not-star-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character"))))
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character-not-star-or-slash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character-not-star-or-slash"))))
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character-not-single-quote-or-backslash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character-not-new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character-not-new-line"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "basic-character-not-double-quote-or-backslash") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "basic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "extended-character-not-new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "extended-character-not-new-line"))))
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-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-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 "string-literal") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "string-literal"))))
Theorem:
(defthm cst-token-conc5-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-gcc-keyword-conc1-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-gcc-keyword-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"asm\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"asm\""))))
Theorem:
(defthm cst-gcc-keyword-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"__asm__\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"__asm__\""))))
Theorem:
(defthm cst-gcc-keyword-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"__attribute__\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"__attribute__\""))))
Theorem:
(defthm cst-gcc-keyword-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"__extension__\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"__extension__\""))))
Theorem:
(defthm cst-gcc-keyword-conc6-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-gcc-keyword-conc7-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-gcc-keyword-conc8-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-gcc-keyword-conc9-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-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 "letter") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "letter"))))
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 "floating-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "floating-constant"))))
Theorem:
(defthm cst-constant-conc3-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-constant-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "character-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "character-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-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x31-39") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x31-39"))))
Theorem:
(defthm cst-octal-digit-conc-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x30-37") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x30-37"))))
Theorem:
(defthm cst-hexadecimal-digit-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x30-39") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x30-39"))))
Theorem:
(defthm cst-hexadecimal-digit-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x61-66") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x61-66"))))
Theorem:
(defthm cst-hexadecimal-digit-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%x41-46") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%x41-46"))))
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-floating-constant-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "decimal-floating-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "decimal-floating-constant"))))
Theorem:
(defthm cst-floating-constant-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "hexadecimal-floating-constant") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hexadecimal-floating-constant"))))
Theorem:
(defthm cst-sign-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"+\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"+\""))))
Theorem:
(defthm cst-sign-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "\"-\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "\"-\""))))
Theorem:
(defthm cst-digit-sequence-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "digit"))))
Theorem:
(defthm cst-hexadecimal-digit-sequence-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "hexadecimal-digit") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hexadecimal-digit"))))
Theorem:
(defthm cst-floating-suffix-conc1-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-floating-suffix-conc2-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-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-c-char-sequence-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "c-char") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "c-char"))))
Theorem:
(defthm cst-c-char-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "character-not-single-quote-or-backslash-or-new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "character-not-single-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-c-char-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "simple-escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "simple-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "octal-escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "octal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "hexadecimal-escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "hexadecimal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc4-rep-matching (implies (cst-list-rep-matchp abnf::csts "universal-character-name") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "universal-character-name"))))
Theorem:
(defthm cst-simple-escape-sequence-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-simple-escape-sequence-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-simple-escape-sequence-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-simple-escape-sequence-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\a\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\a\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc6-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\b\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\b\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc7-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\f\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\f\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc8-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\n\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\n\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc9-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\r\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\r\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc10-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\t\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\t\""))))
Theorem:
(defthm cst-simple-escape-sequence-conc11-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"\\v\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"\\v\""))))
Theorem:
(defthm cst-encoding-prefix-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"u8\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"u8\""))))
Theorem:
(defthm cst-encoding-prefix-conc2-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-encoding-prefix-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"L\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"L\""))))
Theorem:
(defthm cst-s-char-sequence-conc1-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-s-char-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "character-not-double-quote-or-backslash-or-new-line") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "character-not-double-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-s-char-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "escape-sequence") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "escape-sequence"))))
Theorem:
(defthm cst-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-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-primary-expression-conc2-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-primary-expression-conc5-rep-matching (implies (cst-list-rep-matchp abnf::csts "generic-selection") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "generic-selection"))))
Theorem:
(defthm cst-generic-assoc-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "generic-association") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "generic-association"))))
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-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-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-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "static-assert-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "static-assert-declaration"))))
Theorem:
(defthm cst-init-declarator-list-conc1-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-conc1-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-storage-class-specifier-conc2-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-storage-class-specifier-conc3-rep-matching (implies (cst-list-rep-matchp abnf::csts "%s\"static\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"static\""))))
Theorem:
(defthm cst-storage-class-specifier-conc4-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-storage-class-specifier-conc5-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-storage-class-specifier-conc6-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-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 "%s\"_Complex\"") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "%s\"_Complex\""))))
Theorem:
(defthm cst-type-specifier-conc12-rep-matching (implies (cst-list-rep-matchp abnf::csts "atomic-type-specifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "atomic-type-specifier"))))
Theorem:
(defthm cst-type-specifier-conc13-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-conc14-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-conc15-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-declaration-conc2-rep-matching (implies (cst-list-rep-matchp abnf::csts "static-assert-declaration") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "static-assert-declaration"))))
Theorem:
(defthm cst-struct-declarator-list-conc1-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-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-enumerator-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "enumerator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "enumerator"))))
Theorem:
(defthm cst-enumerator-conc1-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-type-qualifier-conc1-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-type-qualifier-conc2-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-type-qualifier-conc3-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-type-qualifier-conc4-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-function-specifier-conc1-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-function-specifier-conc2-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-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-type-qualifier-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "type-qualifier") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "type-qualifier"))))
Theorem:
(defthm cst-parameter-type-list-conc1-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-identifier-list-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-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-designator-list-conc1-rep-matching (implies (cst-list-rep-matchp abnf::csts "designator") (and (equal (len abnf::csts) 1) (cst-matchp (nth 0 abnf::csts) "designator"))))
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-letter-conc-equivs (implies (cst-matchp abnf::cst "letter") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "uppercase-letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "uppercase-letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "lowercase-letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "lowercase-letter"))))))
Theorem:
(defthm cst-control-character-conc-equivs (implies (cst-matchp abnf::cst "control-character") (and (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"))))))
Theorem:
(defthm cst-basic-character-conc-equivs (implies (cst-matchp abnf::cst "basic-character") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character"))) (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) "control-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character"))))))
Theorem:
(defthm cst-character-conc-equivs (implies (cst-matchp abnf::cst "character") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character"))))))
Theorem:
(defthm cst-basic-character-not-star-conc-equivs (implies (cst-matchp abnf::cst "basic-character-not-star") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-star") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-star"))) (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) "control-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character"))))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc-equivs (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-star-or-slash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-star-or-slash"))) (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) "control-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character"))))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc-equivs (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-single-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-single-quote-or-backslash"))) (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) "control-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character"))))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc-equivs (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-double-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-double-quote-or-backslash"))) (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) "control-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character"))))))
Theorem:
(defthm cst-character-not-new-line-conc-equivs (implies (cst-matchp abnf::cst "character-not-new-line") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line"))))))
Theorem:
(defthm cst-character-not-star-conc-equivs (implies (cst-matchp abnf::cst "character-not-star") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-star"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character"))))))
Theorem:
(defthm cst-character-not-star-or-slash-conc-equivs (implies (cst-matchp abnf::cst "character-not-star-or-slash") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star-or-slash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-star-or-slash"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character"))))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc-equivs (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-single-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-single-quote-or-backslash"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line"))))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc-equivs (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-double-quote-or-backslash") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-double-quote-or-backslash"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line"))))))
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-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-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) "string-literal") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "string-literal"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "punctuator") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "punctuator"))))))
Theorem:
(defthm cst-nondigit-conc-equivs (implies (cst-matchp abnf::cst "nondigit") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "\"_\"") (abnf::tree-case (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst))) :leafterm)) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter") (abnf::tree-case (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst))) :nonleaf)))))
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) "floating-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "floating-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"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-constant"))))))
Theorem:
(defthm cst-floating-constant-conc-equivs (implies (cst-matchp abnf::cst "floating-constant") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-floating-constant"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-floating-constant") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-floating-constant"))))))
Theorem:
(defthm cst-c-char-conc-equivs (implies (cst-matchp abnf::cst "c-char") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-single-quote-or-backslash-or-new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-not-single-quote-or-backslash-or-new-line"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence"))))))
Theorem:
(defthm cst-escape-sequence-conc-equivs (implies (cst-matchp abnf::cst "escape-sequence") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "simple-escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "simple-escape-sequence"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "octal-escape-sequence"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-escape-sequence"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "universal-character-name") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "universal-character-name"))))))
Theorem:
(defthm cst-s-char-conc-equivs (implies (cst-matchp abnf::cst "s-char") (and (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-double-quote-or-backslash-or-new-line") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-not-double-quote-or-backslash-or-new-line"))) (iff (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence") (equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence"))))))
Theorem:
(defthm cst-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-letter-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "letter"))) (let ((__function__ 'cst-letter-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "uppercase-letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "lowercase-letter")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-letter-conc? (b* ((number (cst-letter-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc?-possibilities (b* ((number (cst-letter-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-letter-conc? abnf::cst)))))
Theorem:
(defthm cst-letter-conc?-of-tree-fix-cst (equal (cst-letter-conc? (abnf::tree-fix abnf::cst)) (cst-letter-conc? abnf::cst)))
Theorem:
(defthm cst-letter-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc? abnf::cst) (cst-letter-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-letter-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "letter") (iff (equal (cst-letter-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "uppercase-letter"))))
Theorem:
(defthm cst-letter-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "letter") (iff (equal (cst-letter-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "lowercase-letter"))))
Function:
(defun cst-control-character-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "control-character"))) (let ((__function__ 'cst-control-character-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "horizontal-tab")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "vertical-tab")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "form-feed")) 3) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-control-character-conc? (b* ((number (cst-control-character-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc?-possibilities (b* ((number (cst-control-character-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((cst-control-character-conc? abnf::cst)))))
Theorem:
(defthm cst-control-character-conc?-of-tree-fix-cst (equal (cst-control-character-conc? (abnf::tree-fix abnf::cst)) (cst-control-character-conc? abnf::cst)))
Theorem:
(defthm cst-control-character-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc? abnf::cst) (cst-control-character-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-control-character-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "control-character") (iff (equal (cst-control-character-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "horizontal-tab"))))
Theorem:
(defthm cst-control-character-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "control-character") (iff (equal (cst-control-character-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "vertical-tab"))))
Theorem:
(defthm cst-control-character-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "control-character") (iff (equal (cst-control-character-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "form-feed"))))
Function:
(defun cst-basic-character-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-character"))) (let ((__function__ 'cst-basic-character-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-basic-character-conc? (b* ((number (cst-basic-character-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc?-possibilities (b* ((number (cst-basic-character-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-basic-character-conc? abnf::cst)))))
Theorem:
(defthm cst-basic-character-conc?-of-tree-fix-cst (equal (cst-basic-character-conc? (abnf::tree-fix abnf::cst)) (cst-basic-character-conc? abnf::cst)))
Theorem:
(defthm cst-basic-character-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc? abnf::cst) (cst-basic-character-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-basic-character-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "basic-character") (iff (equal (cst-basic-character-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter"))))
Theorem:
(defthm cst-basic-character-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "basic-character") (iff (equal (cst-basic-character-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit"))))
Theorem:
(defthm cst-basic-character-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "basic-character") (iff (equal (cst-basic-character-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character"))))
Theorem:
(defthm cst-basic-character-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "basic-character") (iff (equal (cst-basic-character-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-basic-character-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "basic-character") (iff (equal (cst-basic-character-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "control-character"))))
Function:
(defun cst-character-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character"))) (let ((__function__ 'cst-character-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-conc? (b* ((number (cst-character-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc?-possibilities (b* ((number (cst-character-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-conc? abnf::cst)))))
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)
Theorem:
(defthm cst-character-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character") (iff (equal (cst-character-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character"))))
Theorem:
(defthm cst-character-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character") (iff (equal (cst-character-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character"))))
Function:
(defun cst-basic-character-not-star-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-character-not-star"))) (let ((__function__ 'cst-basic-character-not-star-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-star")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-basic-character-not-star-conc? (b* ((number (cst-basic-character-not-star-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc?-possibilities (b* ((number (cst-basic-character-not-star-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-basic-character-not-star-conc? abnf::cst)))))
Theorem:
(defthm cst-basic-character-not-star-conc?-of-tree-fix-cst (equal (cst-basic-character-not-star-conc? (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc? abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc? abnf::cst) (cst-basic-character-not-star-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-basic-character-not-star-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star") (iff (equal (cst-basic-character-not-star-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star") (iff (equal (cst-basic-character-not-star-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star") (iff (equal (cst-basic-character-not-star-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-star"))))
Theorem:
(defthm cst-basic-character-not-star-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star") (iff (equal (cst-basic-character-not-star-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-basic-character-not-star-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star") (iff (equal (cst-basic-character-not-star-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "control-character"))))
Function:
(defun cst-basic-character-not-star-or-slash-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-character-not-star-or-slash"))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-star-or-slash")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-basic-character-not-star-or-slash-conc? (b* ((number (cst-basic-character-not-star-or-slash-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-possibilities (b* ((number (cst-basic-character-not-star-or-slash-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-basic-character-not-star-or-slash-conc? abnf::cst)))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc? (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc? abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) (cst-basic-character-not-star-or-slash-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (iff (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (iff (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (iff (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-star-or-slash"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (iff (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-star-or-slash") (iff (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "control-character"))))
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash"))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-single-quote-or-backslash")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-basic-character-not-single-quote-or-backslash-conc? (b* ((number (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-possibilities (b* ((number (cst-basic-character-not-single-quote-or-backslash-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-basic-character-not-single-quote-or-backslash-conc? abnf::cst)))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc? (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "control-character"))))
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash"))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "letter")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "digit")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "graphic-character-not-double-quote-or-backslash")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "space")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "control-character")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-basic-character-not-double-quote-or-backslash-conc? (b* ((number (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-possibilities (b* ((number (cst-basic-character-not-double-quote-or-backslash-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-basic-character-not-double-quote-or-backslash-conc? abnf::cst)))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc? (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "letter"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "digit"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "graphic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "space"))))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "control-character"))))
Function:
(defun cst-character-not-new-line-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character-not-new-line"))) (let ((__function__ 'cst-character-not-new-line-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-not-new-line-conc? (b* ((number (cst-character-not-new-line-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc?-possibilities (b* ((number (cst-character-not-new-line-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-not-new-line-conc? abnf::cst)))))
Theorem:
(defthm cst-character-not-new-line-conc?-of-tree-fix-cst (equal (cst-character-not-new-line-conc? (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc? abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc? abnf::cst) (cst-character-not-new-line-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-character-not-new-line-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character-not-new-line") (iff (equal (cst-character-not-new-line-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character"))))
Theorem:
(defthm cst-character-not-new-line-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character-not-new-line") (iff (equal (cst-character-not-new-line-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line"))))
Function:
(defun cst-character-not-star-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character-not-star"))) (let ((__function__ 'cst-character-not-star-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-star")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-not-star-conc? (b* ((number (cst-character-not-star-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc?-possibilities (b* ((number (cst-character-not-star-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-not-star-conc? abnf::cst)))))
Theorem:
(defthm cst-character-not-star-conc?-of-tree-fix-cst (equal (cst-character-not-star-conc? (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc? abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc? abnf::cst) (cst-character-not-star-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-character-not-star-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character-not-star") (iff (equal (cst-character-not-star-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star"))))
Theorem:
(defthm cst-character-not-star-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character-not-star") (iff (equal (cst-character-not-star-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character"))))
Function:
(defun cst-character-not-star-or-slash-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character-not-star-or-slash"))) (let ((__function__ 'cst-character-not-star-or-slash-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-star-or-slash")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-not-star-or-slash-conc? (b* ((number (cst-character-not-star-or-slash-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc?-possibilities (b* ((number (cst-character-not-star-or-slash-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-not-star-or-slash-conc? abnf::cst)))))
Theorem:
(defthm cst-character-not-star-or-slash-conc?-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc? (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc? abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc? abnf::cst) (cst-character-not-star-or-slash-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-character-not-star-or-slash-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character-not-star-or-slash") (iff (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-star-or-slash"))))
Theorem:
(defthm cst-character-not-star-or-slash-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character-not-star-or-slash") (iff (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character"))))
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line"))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-single-quote-or-backslash")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc? (b* ((number (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc?-possibilities (b* ((number (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst)))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (iff (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-single-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (iff (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line"))))
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line"))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "basic-character-not-double-quote-or-backslash")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "extended-character-not-new-line")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc? (b* ((number (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc?-possibilities (b* ((number (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst)))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (iff (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "basic-character-not-double-quote-or-backslash"))))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (iff (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "extended-character-not-new-line"))))
Function:
(defun cst-white-space-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "white-space"))) (let ((__function__ 'cst-white-space-conc?)) (declare (ignorable __function__)) (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-comment-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "comment"))) (let ((__function__ 'cst-comment-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "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-token-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "token"))) (let ((__function__ 'cst-token-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "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 "string-literal")) 4) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "punctuator")) 5) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-token-conc? (b* ((number (cst-token-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc?-possibilities (b* ((number (cst-token-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5))) :rule-classes ((:forward-chaining :trigger-terms ((cst-token-conc? abnf::cst)))))
Theorem:
(defthm cst-token-conc?-of-tree-fix-cst (equal (cst-token-conc? (abnf::tree-fix abnf::cst)) (cst-token-conc? abnf::cst)))
Theorem:
(defthm cst-token-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc? abnf::cst) (cst-token-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-token-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "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) "string-literal"))))
Theorem:
(defthm cst-token-conc?-5-iff-match-conc (implies (cst-matchp abnf::cst "token") (iff (equal (cst-token-conc? abnf::cst) 5) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "punctuator"))))
Function:
(defun cst-constant-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant"))) (let ((__function__ 'cst-constant-conc?)) (declare (ignorable __function__)) (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 "floating-constant")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "enumeration-constant")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-constant")) 4) (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) (equal number 3) (equal number 4))) :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) "floating-constant"))))
Theorem:
(defthm cst-constant-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "constant") (iff (equal (cst-constant-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "enumeration-constant"))))
Theorem:
(defthm cst-constant-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "constant") (iff (equal (cst-constant-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-constant"))))
Function:
(defun cst-floating-constant-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "floating-constant"))) (let ((__function__ 'cst-floating-constant-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "decimal-floating-constant")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-floating-constant")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-floating-constant-conc? (b* ((number (cst-floating-constant-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc?-possibilities (b* ((number (cst-floating-constant-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-floating-constant-conc? abnf::cst)))))
Theorem:
(defthm cst-floating-constant-conc?-of-tree-fix-cst (equal (cst-floating-constant-conc? (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc? abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc? abnf::cst) (cst-floating-constant-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-floating-constant-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "floating-constant") (iff (equal (cst-floating-constant-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "decimal-floating-constant"))))
Theorem:
(defthm cst-floating-constant-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "floating-constant") (iff (equal (cst-floating-constant-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-floating-constant"))))
Function:
(defun cst-c-char-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "c-char"))) (let ((__function__ 'cst-c-char-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-not-single-quote-or-backslash-or-new-line")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-c-char-conc? (b* ((number (cst-c-char-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc?-possibilities (b* ((number (cst-c-char-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-c-char-conc? abnf::cst)))))
Theorem:
(defthm cst-c-char-conc?-of-tree-fix-cst (equal (cst-c-char-conc? (abnf::tree-fix abnf::cst)) (cst-c-char-conc? abnf::cst)))
Theorem:
(defthm cst-c-char-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc? abnf::cst) (cst-c-char-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-c-char-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "c-char") (iff (equal (cst-c-char-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-single-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-c-char-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "c-char") (iff (equal (cst-c-char-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence"))))
Function:
(defun cst-escape-sequence-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "escape-sequence"))) (let ((__function__ 'cst-escape-sequence-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "simple-escape-sequence")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "octal-escape-sequence")) 2) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "hexadecimal-escape-sequence")) 3) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "universal-character-name")) 4) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-escape-sequence-conc? (b* ((number (cst-escape-sequence-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc?-possibilities (b* ((number (cst-escape-sequence-conc? abnf::cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((cst-escape-sequence-conc? abnf::cst)))))
Theorem:
(defthm cst-escape-sequence-conc?-of-tree-fix-cst (equal (cst-escape-sequence-conc? (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc? abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc? abnf::cst) (cst-escape-sequence-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-escape-sequence-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "escape-sequence") (iff (equal (cst-escape-sequence-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "simple-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "escape-sequence") (iff (equal (cst-escape-sequence-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "octal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc?-3-iff-match-conc (implies (cst-matchp abnf::cst "escape-sequence") (iff (equal (cst-escape-sequence-conc? abnf::cst) 3) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "hexadecimal-escape-sequence"))))
Theorem:
(defthm cst-escape-sequence-conc?-4-iff-match-conc (implies (cst-matchp abnf::cst "escape-sequence") (iff (equal (cst-escape-sequence-conc? abnf::cst) 4) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "universal-character-name"))))
Function:
(defun cst-s-char-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "s-char"))) (let ((__function__ 'cst-s-char-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "character-not-double-quote-or-backslash-or-new-line")) 1) ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "escape-sequence")) 2) (t (prog2$ (impossible) 1)))))
Theorem:
(defthm posp-of-cst-s-char-conc? (b* ((number (cst-s-char-conc? abnf::cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc?-possibilities (b* ((number (cst-s-char-conc? abnf::cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((cst-s-char-conc? abnf::cst)))))
Theorem:
(defthm cst-s-char-conc?-of-tree-fix-cst (equal (cst-s-char-conc? (abnf::tree-fix abnf::cst)) (cst-s-char-conc? abnf::cst)))
Theorem:
(defthm cst-s-char-conc?-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc? abnf::cst) (cst-s-char-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm cst-s-char-conc?-1-iff-match-conc (implies (cst-matchp abnf::cst "s-char") (iff (equal (cst-s-char-conc? abnf::cst) 1) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "character-not-double-quote-or-backslash-or-new-line"))))
Theorem:
(defthm cst-s-char-conc?-2-iff-match-conc (implies (cst-matchp abnf::cst "s-char") (iff (equal (cst-s-char-conc? abnf::cst) 2) (cst-list-list-conc-matchp (abnf::tree-nonleaf->branches abnf::cst) "escape-sequence"))))
Function:
(defun cst-lexeme-conc? (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lexeme"))) (let ((__function__ 'cst-lexeme-conc?)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-statement-conc?)) (declare (ignorable __function__)) (cond ((equal (abnf::tree-nonleaf->rulename? (nth 0 (nth 0 (abnf::tree-nonleaf->branches abnf::cst)))) (abnf::rulename "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"))) (let ((__function__ 'cst-block-item-conc?)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-external-declaration-conc?)) (declare (ignorable __function__)) (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-uppercase-letter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter"))) (let ((__function__ 'cst-uppercase-letter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-uppercase-letter-conc (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-match (implies (cst-matchp abnf::cst "uppercase-letter") (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x41-5A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-of-tree-fix-cst (equal (cst-uppercase-letter-conc (abnf::tree-fix abnf::cst)) (cst-uppercase-letter-conc abnf::cst)))
Theorem:
(defthm cst-uppercase-letter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-uppercase-letter-conc abnf::cst) (cst-uppercase-letter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lowercase-letter-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter"))) (let ((__function__ 'cst-lowercase-letter-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-lowercase-letter-conc (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-match (implies (cst-matchp abnf::cst "lowercase-letter") (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x61-7A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-of-tree-fix-cst (equal (cst-lowercase-letter-conc (abnf::tree-fix abnf::cst)) (cst-lowercase-letter-conc abnf::cst)))
Theorem:
(defthm cst-lowercase-letter-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lowercase-letter-conc abnf::cst) (cst-lowercase-letter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)))) (let ((__function__ 'cst-letter-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-letter-conc1 (b* ((abnf::cstss (cst-letter-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-letter-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "uppercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-of-tree-fix-cst (equal (cst-letter-conc1 (abnf::tree-fix abnf::cst)) (cst-letter-conc1 abnf::cst)))
Theorem:
(defthm cst-letter-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc1 abnf::cst) (cst-letter-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)))) (let ((__function__ 'cst-letter-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-letter-conc2 (b* ((abnf::cstss (cst-letter-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-letter-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "lowercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-of-tree-fix-cst (equal (cst-letter-conc2 (abnf::tree-fix abnf::cst)) (cst-letter-conc2 abnf::cst)))
Theorem:
(defthm cst-letter-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc2 abnf::cst) (cst-letter-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-digit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "digit"))) (let ((__function__ 'cst-digit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-digit-conc (b* ((abnf::cstss (cst-digit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-match (implies (cst-matchp abnf::cst "digit") (b* ((abnf::cstss (cst-digit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-of-tree-fix-cst (equal (cst-digit-conc (abnf::tree-fix abnf::cst)) (cst-digit-conc abnf::cst)))
Theorem:
(defthm cst-digit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-digit-conc abnf::cst) (cst-digit-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"))) (let ((__function__ 'cst-double-quote-conc)) (declare (ignorable __function__)) (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-space-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (let ((__function__ 'cst-space-conc)) (declare (ignorable __function__)) (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-horizontal-tab-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (let ((__function__ 'cst-horizontal-tab-conc)) (declare (ignorable __function__)) (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-vertical-tab-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (let ((__function__ 'cst-vertical-tab-conc)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-form-feed-conc)) (declare (ignorable __function__)) (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-control-character-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-control-character-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-control-character-conc1 (b* ((abnf::cstss (cst-control-character-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-control-character-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-of-tree-fix-cst (equal (cst-control-character-conc1 (abnf::tree-fix abnf::cst)) (cst-control-character-conc1 abnf::cst)))
Theorem:
(defthm cst-control-character-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc1 abnf::cst) (cst-control-character-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-control-character-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-control-character-conc2 (b* ((abnf::cstss (cst-control-character-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-control-character-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-of-tree-fix-cst (equal (cst-control-character-conc2 (abnf::tree-fix abnf::cst)) (cst-control-character-conc2 abnf::cst)))
Theorem:
(defthm cst-control-character-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc2 abnf::cst) (cst-control-character-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-control-character-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-control-character-conc3 (b* ((abnf::cstss (cst-control-character-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-control-character-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-of-tree-fix-cst (equal (cst-control-character-conc3 (abnf::tree-fix abnf::cst)) (cst-control-character-conc3 abnf::cst)))
Theorem:
(defthm cst-control-character-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc3 abnf::cst) (cst-control-character-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-conc1 (b* ((abnf::cstss (cst-basic-character-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-basic-character-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-of-tree-fix-cst (equal (cst-basic-character-conc1 (abnf::tree-fix abnf::cst)) (cst-basic-character-conc1 abnf::cst)))
Theorem:
(defthm cst-basic-character-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc1 abnf::cst) (cst-basic-character-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-conc2 (b* ((abnf::cstss (cst-basic-character-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-basic-character-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-of-tree-fix-cst (equal (cst-basic-character-conc2 (abnf::tree-fix abnf::cst)) (cst-basic-character-conc2 abnf::cst)))
Theorem:
(defthm cst-basic-character-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc2 abnf::cst) (cst-basic-character-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-conc3 (b* ((abnf::cstss (cst-basic-character-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-basic-character-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "graphic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-of-tree-fix-cst (equal (cst-basic-character-conc3 (abnf::tree-fix abnf::cst)) (cst-basic-character-conc3 abnf::cst)))
Theorem:
(defthm cst-basic-character-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc3 abnf::cst) (cst-basic-character-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-conc4 (b* ((abnf::cstss (cst-basic-character-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-basic-character-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-of-tree-fix-cst (equal (cst-basic-character-conc4 (abnf::tree-fix abnf::cst)) (cst-basic-character-conc4 abnf::cst)))
Theorem:
(defthm cst-basic-character-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc4 abnf::cst) (cst-basic-character-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-conc5 (b* ((abnf::cstss (cst-basic-character-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-basic-character-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-of-tree-fix-cst (equal (cst-basic-character-conc5 (abnf::tree-fix abnf::cst)) (cst-basic-character-conc5 abnf::cst)))
Theorem:
(defthm cst-basic-character-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc5 abnf::cst) (cst-basic-character-conc5 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"))) (let ((__function__ 'cst-line-feed-conc)) (declare (ignorable __function__)) (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-carriage-return-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (let ((__function__ 'cst-carriage-return-conc)) (declare (ignorable __function__)) (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-character-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-conc1 (b* ((abnf::cstss (cst-character-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-of-tree-fix-cst (equal (cst-character-conc1 (abnf::tree-fix abnf::cst)) (cst-character-conc1 abnf::cst)))
Theorem:
(defthm cst-character-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc1 abnf::cst) (cst-character-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-conc2 (b* ((abnf::cstss (cst-character-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-of-tree-fix-cst (equal (cst-character-conc2 (abnf::tree-fix abnf::cst)) (cst-character-conc2 abnf::cst)))
Theorem:
(defthm cst-character-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc2 abnf::cst) (cst-character-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-conc1 (b* ((abnf::cstss (cst-basic-character-not-star-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-basic-character-not-star-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-of-tree-fix-cst (equal (cst-basic-character-not-star-conc1 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc1 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc1 abnf::cst) (cst-basic-character-not-star-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-conc2 (b* ((abnf::cstss (cst-basic-character-not-star-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-basic-character-not-star-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-of-tree-fix-cst (equal (cst-basic-character-not-star-conc2 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc2 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc2 abnf::cst) (cst-basic-character-not-star-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-conc3 (b* ((abnf::cstss (cst-basic-character-not-star-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-basic-character-not-star-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-of-tree-fix-cst (equal (cst-basic-character-not-star-conc3 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc3 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc3 abnf::cst) (cst-basic-character-not-star-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-conc4 (b* ((abnf::cstss (cst-basic-character-not-star-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-basic-character-not-star-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-of-tree-fix-cst (equal (cst-basic-character-not-star-conc4 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc4 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc4 abnf::cst) (cst-basic-character-not-star-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-conc5 (b* ((abnf::cstss (cst-basic-character-not-star-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-basic-character-not-star-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-of-tree-fix-cst (equal (cst-basic-character-not-star-conc5 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc5 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc5 abnf::cst) (cst-basic-character-not-star-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-or-slash-conc1 (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc1 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc1 abnf::cst) (cst-basic-character-not-star-or-slash-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-or-slash-conc2 (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc2 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc2 abnf::cst) (cst-basic-character-not-star-or-slash-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-or-slash-conc3 (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc3 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc3 abnf::cst) (cst-basic-character-not-star-or-slash-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-or-slash-conc4 (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc4 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc4 abnf::cst) (cst-basic-character-not-star-or-slash-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-star-or-slash-conc5 (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-basic-character-not-star-or-slash-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc5 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc5 abnf::cst) (cst-basic-character-not-star-or-slash-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc1 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc1 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc1 abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc2 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc2 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc2 abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc3 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc3 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc3 abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc4 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc4 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc4 abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc5 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc5 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc5 abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc1 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc1 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc1 abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc2 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc2 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc2 abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "graphic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc3 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc3 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc3 abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc4 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc4 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc4 abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc5 (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc5 abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc5 abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-new-line-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-new-line-conc1 (b* ((abnf::cstss (cst-character-not-new-line-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-not-new-line-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-of-tree-fix-cst (equal (cst-character-not-new-line-conc1 (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc1 abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc1 abnf::cst) (cst-character-not-new-line-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-new-line-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-new-line-conc2 (b* ((abnf::cstss (cst-character-not-new-line-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-not-new-line-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-of-tree-fix-cst (equal (cst-character-not-new-line-conc2 (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc2 abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc2 abnf::cst) (cst-character-not-new-line-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-star-conc1 (b* ((abnf::cstss (cst-character-not-star-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-not-star-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-of-tree-fix-cst (equal (cst-character-not-star-conc1 (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc1 abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc1 abnf::cst) (cst-character-not-star-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-star-conc2 (b* ((abnf::cstss (cst-character-not-star-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-not-star-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-of-tree-fix-cst (equal (cst-character-not-star-conc2 (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc2 abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc2 abnf::cst) (cst-character-not-star-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-or-slash-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-star-or-slash-conc1 (b* ((abnf::cstss (cst-character-not-star-or-slash-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-not-star-or-slash-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc1 (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc1 abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc1 abnf::cst) (cst-character-not-star-or-slash-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-or-slash-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-star-or-slash-conc2 (b* ((abnf::cstss (cst-character-not-star-or-slash-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-not-star-or-slash-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc2 (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc2 abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc2 abnf::cst) (cst-character-not-star-or-slash-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1 (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1 (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc1 abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1 abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2 (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2 (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc2 abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2 abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1 (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "basic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1 (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc1 abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1 abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2 (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2 (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc2 abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2 abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-conc2 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)))) (let ((__function__ 'cst-white-space-conc1)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc2)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc3)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc4)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc5)) (declare (ignorable __function__)) (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-comment-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-comment-conc1 (b* ((abnf::cstss (cst-comment-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-comment-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-comment-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-comment-conc2 (b* ((abnf::cstss (cst-comment-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-comment-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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"))) (let ((__function__ 'cst-block-comment-conc)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-line-comment-conc)) (declare (ignorable __function__)) (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 "\"//\" *character-not-new-line"))) :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-token-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc1 (b* ((abnf::cstss (cst-token-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-token-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-token-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc2 (b* ((abnf::cstss (cst-token-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-token-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-token-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc3 (b* ((abnf::cstss (cst-token-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-token-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-token-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc4 (b* ((abnf::cstss (cst-token-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-token-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-of-tree-fix-cst (equal (cst-token-conc4 (abnf::tree-fix abnf::cst)) (cst-token-conc4 abnf::cst)))
Theorem:
(defthm cst-token-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4 abnf::cst) (cst-token-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-token-conc5 (b* ((abnf::cstss (cst-token-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-token-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "punctuator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-of-tree-fix-cst (equal (cst-token-conc5 (abnf::tree-fix abnf::cst)) (cst-token-conc5 abnf::cst)))
Theorem:
(defthm cst-token-conc5-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5 abnf::cst) (cst-token-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-nondigit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (let ((__function__ 'cst-identifier-nondigit-conc)) (declare (ignorable __function__)) (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-hex-quad-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "hex-quad"))) (let ((__function__ 'cst-hex-quad-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-hex-quad-conc (b* ((abnf::cstss (cst-hex-quad-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-quad-conc-match (implies (cst-matchp abnf::cst "hex-quad") (b* ((abnf::cstss (cst-hex-quad-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-hex-quad-conc-of-tree-fix-cst (equal (cst-hex-quad-conc (abnf::tree-fix abnf::cst)) (cst-hex-quad-conc abnf::cst)))
Theorem:
(defthm cst-hex-quad-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-hex-quad-conc abnf::cst) (cst-hex-quad-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)))) (let ((__function__ 'cst-constant-conc1)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-constant-conc2)) (declare (ignorable __function__)) (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 "floating-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-constant-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 3)))) (let ((__function__ 'cst-constant-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constant-conc3 (b* ((abnf::cstss (cst-constant-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-constant-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-of-tree-fix-cst (equal (cst-constant-conc3 (abnf::tree-fix abnf::cst)) (cst-constant-conc3 abnf::cst)))
Theorem:
(defthm cst-constant-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc3 abnf::cst) (cst-constant-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 4)))) (let ((__function__ 'cst-constant-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constant-conc4 (b* ((abnf::cstss (cst-constant-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-constant-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "character-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-of-tree-fix-cst (equal (cst-constant-conc4 (abnf::tree-fix abnf::cst)) (cst-constant-conc4 abnf::cst)))
Theorem:
(defthm cst-constant-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc4 abnf::cst) (cst-constant-conc4 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"))) (let ((__function__ 'cst-hexadecimal-prefix-conc)) (declare (ignorable __function__)) (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-nonzero-digit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit"))) (let ((__function__ 'cst-nonzero-digit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-nonzero-digit-conc (b* ((abnf::cstss (cst-nonzero-digit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-match (implies (cst-matchp abnf::cst "nonzero-digit") (b* ((abnf::cstss (cst-nonzero-digit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-of-tree-fix-cst (equal (cst-nonzero-digit-conc (abnf::tree-fix abnf::cst)) (cst-nonzero-digit-conc abnf::cst)))
Theorem:
(defthm cst-nonzero-digit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-nonzero-digit-conc abnf::cst) (cst-nonzero-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-octal-digit-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "octal-digit"))) (let ((__function__ 'cst-octal-digit-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-octal-digit-conc (b* ((abnf::cstss (cst-octal-digit-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-match (implies (cst-matchp abnf::cst "octal-digit") (b* ((abnf::cstss (cst-octal-digit-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%x30-37"))) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-of-tree-fix-cst (equal (cst-octal-digit-conc (abnf::tree-fix abnf::cst)) (cst-octal-digit-conc abnf::cst)))
Theorem:
(defthm cst-octal-digit-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-octal-digit-conc abnf::cst) (cst-octal-digit-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"))) (let ((__function__ 'cst-unsigned-suffix-conc)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-long-suffix-conc)) (declare (ignorable __function__)) (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-floating-constant-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-constant-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-floating-constant-conc1 (b* ((abnf::cstss (cst-floating-constant-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-floating-constant-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "decimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-of-tree-fix-cst (equal (cst-floating-constant-conc1 (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc1 abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc1 abnf::cst) (cst-floating-constant-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-constant-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-constant-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-floating-constant-conc2 (b* ((abnf::cstss (cst-floating-constant-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-floating-constant-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hexadecimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-of-tree-fix-cst (equal (cst-floating-constant-conc2 (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc2 abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc2 abnf::cst) (cst-floating-constant-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-exponent-part-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "exponent-part"))) (let ((__function__ 'cst-exponent-part-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-exponent-part-conc (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-part-conc-match (implies (cst-matchp abnf::cst "exponent-part") (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%i\"e\" [ sign ] digit-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-exponent-part-conc-of-tree-fix-cst (equal (cst-exponent-part-conc (abnf::tree-fix abnf::cst)) (cst-exponent-part-conc abnf::cst)))
Theorem:
(defthm cst-exponent-part-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-exponent-part-conc abnf::cst) (cst-exponent-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-binary-exponent-part-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "binary-exponent-part"))) (let ((__function__ 'cst-binary-exponent-part-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-binary-exponent-part-conc (b* ((abnf::cstss (cst-binary-exponent-part-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-part-conc-match (implies (cst-matchp abnf::cst "binary-exponent-part") (b* ((abnf::cstss (cst-binary-exponent-part-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%i\"p\" [ sign ] digit-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-binary-exponent-part-conc-of-tree-fix-cst (equal (cst-binary-exponent-part-conc (abnf::tree-fix abnf::cst)) (cst-binary-exponent-part-conc abnf::cst)))
Theorem:
(defthm cst-binary-exponent-part-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-binary-exponent-part-conc abnf::cst) (cst-binary-exponent-part-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"))) (let ((__function__ 'cst-enumeration-constant-conc)) (declare (ignorable __function__)) (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-c-char-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-c-char-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-c-char-conc1 (b* ((abnf::cstss (cst-c-char-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-c-char-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "character-not-single-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-of-tree-fix-cst (equal (cst-c-char-conc1 (abnf::tree-fix abnf::cst)) (cst-c-char-conc1 abnf::cst)))
Theorem:
(defthm cst-c-char-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc1 abnf::cst) (cst-c-char-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-c-char-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-c-char-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-c-char-conc2 (b* ((abnf::cstss (cst-c-char-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-c-char-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-of-tree-fix-cst (equal (cst-c-char-conc2 (abnf::tree-fix abnf::cst)) (cst-c-char-conc2 abnf::cst)))
Theorem:
(defthm cst-c-char-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc2 abnf::cst) (cst-c-char-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)))) (let ((__function__ 'cst-escape-sequence-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-escape-sequence-conc1 (b* ((abnf::cstss (cst-escape-sequence-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-escape-sequence-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "simple-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-of-tree-fix-cst (equal (cst-escape-sequence-conc1 (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc1 abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc1 abnf::cst) (cst-escape-sequence-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)))) (let ((__function__ 'cst-escape-sequence-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-escape-sequence-conc2 (b* ((abnf::cstss (cst-escape-sequence-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-escape-sequence-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-of-tree-fix-cst (equal (cst-escape-sequence-conc2 (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc2 abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc2 abnf::cst) (cst-escape-sequence-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc3 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)))) (let ((__function__ 'cst-escape-sequence-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-escape-sequence-conc3 (b* ((abnf::cstss (cst-escape-sequence-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-escape-sequence-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "hexadecimal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-of-tree-fix-cst (equal (cst-escape-sequence-conc3 (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc3 abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc3-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc3 abnf::cst) (cst-escape-sequence-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc4 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)))) (let ((__function__ 'cst-escape-sequence-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-escape-sequence-conc4 (b* ((abnf::cstss (cst-escape-sequence-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-escape-sequence-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "universal-character-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-of-tree-fix-cst (equal (cst-escape-sequence-conc4 (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc4 abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc4-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc4 abnf::cst) (cst-escape-sequence-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-string-literal-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "string-literal"))) (let ((__function__ 'cst-string-literal-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-string-literal-conc (b* ((abnf::cstss (cst-string-literal-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-string-literal-conc-match (implies (cst-matchp abnf::cst "string-literal") (b* ((abnf::cstss (cst-string-literal-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote"))) :rule-classes :rewrite)
Theorem:
(defthm cst-string-literal-conc-of-tree-fix-cst (equal (cst-string-literal-conc (abnf::tree-fix abnf::cst)) (cst-string-literal-conc abnf::cst)))
Theorem:
(defthm cst-string-literal-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-string-literal-conc abnf::cst) (cst-string-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-s-char-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-s-char-conc1 (b* ((abnf::cstss (cst-s-char-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-s-char-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "character-not-double-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-of-tree-fix-cst (equal (cst-s-char-conc1 (abnf::tree-fix abnf::cst)) (cst-s-char-conc1 abnf::cst)))
Theorem:
(defthm cst-s-char-conc1-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc1 abnf::cst) (cst-s-char-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc2 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-s-char-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-s-char-conc2 (b* ((abnf::cstss (cst-s-char-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-s-char-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-of-tree-fix-cst (equal (cst-s-char-conc2 (abnf::tree-fix abnf::cst)) (cst-s-char-conc2 abnf::cst)))
Theorem:
(defthm cst-s-char-conc2-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc2 abnf::cst) (cst-s-char-conc2 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)))) (let ((__function__ 'cst-lexeme-conc1)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc2)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc3)) (declare (ignorable __function__)) (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-generic-selection-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "generic-selection"))) (let ((__function__ 'cst-generic-selection-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-generic-selection-conc (b* ((abnf::cstss (cst-generic-selection-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-generic-selection-conc-match (implies (cst-matchp abnf::cst "generic-selection") (b* ((abnf::cstss (cst-generic-selection-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-generic-selection-conc-of-tree-fix-cst (equal (cst-generic-selection-conc (abnf::tree-fix abnf::cst)) (cst-generic-selection-conc abnf::cst)))
Theorem:
(defthm cst-generic-selection-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-generic-selection-conc abnf::cst) (cst-generic-selection-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-expression-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-constant-expression-conc (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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-attribute-parameters-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "attribute-parameters"))) (let ((__function__ 'cst-attribute-parameters-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-attribute-parameters-conc (b* ((abnf::cstss (cst-attribute-parameters-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-parameters-conc-match (implies (cst-matchp abnf::cst "attribute-parameters") (b* ((abnf::cstss (cst-attribute-parameters-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "\"(\" [ assignment-expression *( \",\" assignment-expression ) ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-parameters-conc-of-tree-fix-cst (equal (cst-attribute-parameters-conc (abnf::tree-fix abnf::cst)) (cst-attribute-parameters-conc abnf::cst)))
Theorem:
(defthm cst-attribute-parameters-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-attribute-parameters-conc abnf::cst) (cst-attribute-parameters-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-attribute-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "attribute"))) (let ((__function__ 'cst-attribute-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-attribute-conc (b* ((abnf::cstss (cst-attribute-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-conc-match (implies (cst-matchp abnf::cst "attribute") (b* ((abnf::cstss (cst-attribute-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "identifier [ attribute-parameters ]"))) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-conc-of-tree-fix-cst (equal (cst-attribute-conc (abnf::tree-fix abnf::cst)) (cst-attribute-conc abnf::cst)))
Theorem:
(defthm cst-attribute-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-attribute-conc abnf::cst) (cst-attribute-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-attribute-list-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "attribute-list"))) (let ((__function__ 'cst-attribute-list-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-attribute-list-conc (b* ((abnf::cstss (cst-attribute-list-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-list-conc-match (implies (cst-matchp abnf::cst "attribute-list") (b* ((abnf::cstss (cst-attribute-list-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "attribute *( \",\" attribute )"))) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-list-conc-of-tree-fix-cst (equal (cst-attribute-list-conc (abnf::tree-fix abnf::cst)) (cst-attribute-list-conc abnf::cst)))
Theorem:
(defthm cst-attribute-list-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-attribute-list-conc abnf::cst) (cst-attribute-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-attribute-specifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "attribute-specifier"))) (let ((__function__ 'cst-attribute-specifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-attribute-specifier-conc (b* ((abnf::cstss (cst-attribute-specifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-specifier-conc-match (implies (cst-matchp abnf::cst "attribute-specifier") (b* ((abnf::cstss (cst-attribute-specifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\" \"(\" \"(\" [ attribute-list ] \")\" \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-attribute-specifier-conc-of-tree-fix-cst (equal (cst-attribute-specifier-conc (abnf::tree-fix abnf::cst)) (cst-attribute-specifier-conc abnf::cst)))
Theorem:
(defthm cst-attribute-specifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-attribute-specifier-conc abnf::cst) (cst-attribute-specifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-asm-name-specifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "asm-name-specifier"))) (let ((__function__ 'cst-asm-name-specifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-asm-name-specifier-conc (b* ((abnf::cstss (cst-asm-name-specifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-asm-name-specifier-conc-match (implies (cst-matchp abnf::cst "asm-name-specifier") (b* ((abnf::cstss (cst-asm-name-specifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "( %s\"asm\" / %s\"__asm__\" ) \"(\" 1*string-literal \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-asm-name-specifier-conc-of-tree-fix-cst (equal (cst-asm-name-specifier-conc (abnf::tree-fix abnf::cst)) (cst-asm-name-specifier-conc abnf::cst)))
Theorem:
(defthm cst-asm-name-specifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-asm-name-specifier-conc abnf::cst) (cst-asm-name-specifier-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-atomic-type-specifier-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "atomic-type-specifier"))) (let ((__function__ 'cst-atomic-type-specifier-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-atomic-type-specifier-conc (b* ((abnf::cstss (cst-atomic-type-specifier-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-atomic-type-specifier-conc-match (implies (cst-matchp abnf::cst "atomic-type-specifier") (b* ((abnf::cstss (cst-atomic-type-specifier-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\" \"(\" type-name \")\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-atomic-type-specifier-conc-of-tree-fix-cst (equal (cst-atomic-type-specifier-conc (abnf::tree-fix abnf::cst)) (cst-atomic-type-specifier-conc abnf::cst)))
Theorem:
(defthm cst-atomic-type-specifier-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-atomic-type-specifier-conc abnf::cst) (cst-atomic-type-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"))) (let ((__function__ 'cst-declarator-conc)) (declare (ignorable __function__)) (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-type-name-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "type-name"))) (let ((__function__ 'cst-type-name-conc)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-typedef-name-conc)) (declare (ignorable __function__)) (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-designation-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "designation"))) (let ((__function__ 'cst-designation-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-designation-conc (b* ((abnf::cstss (cst-designation-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-designation-conc-match (implies (cst-matchp abnf::cst "designation") (b* ((abnf::cstss (cst-designation-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "designator-list \"=\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-designation-conc-of-tree-fix-cst (equal (cst-designation-conc (abnf::tree-fix abnf::cst)) (cst-designation-conc abnf::cst)))
Theorem:
(defthm cst-designation-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-designation-conc abnf::cst) (cst-designation-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-static-assert-declaration-conc (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "static-assert-declaration"))) (let ((__function__ 'cst-static-assert-declaration-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-static-assert-declaration-conc (b* ((abnf::cstss (cst-static-assert-declaration-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-static-assert-declaration-conc-match (implies (cst-matchp abnf::cst "static-assert-declaration") (b* ((abnf::cstss (cst-static-assert-declaration-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\""))) :rule-classes :rewrite)
Theorem:
(defthm cst-static-assert-declaration-conc-of-tree-fix-cst (equal (cst-static-assert-declaration-conc (abnf::tree-fix abnf::cst)) (cst-static-assert-declaration-conc abnf::cst)))
Theorem:
(defthm cst-static-assert-declaration-conc-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-static-assert-declaration-conc abnf::cst) (cst-static-assert-declaration-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-statement-conc1 (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)))) (let ((__function__ 'cst-statement-conc1)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc1 (b* ((abnf::cstss (cst-statement-conc1 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::cstss (cst-statement-conc1 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-statement-conc2)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc2 (b* ((abnf::cstss (cst-statement-conc2 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::cstss (cst-statement-conc2 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-statement-conc3)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc3 (b* ((abnf::cstss (cst-statement-conc3 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::cstss (cst-statement-conc3 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-statement-conc4)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc4 (b* ((abnf::cstss (cst-statement-conc4 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::cstss (cst-statement-conc4 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-statement-conc5)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc5 (b* ((abnf::cstss (cst-statement-conc5 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::cstss (cst-statement-conc5 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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)))) (let ((__function__ 'cst-statement-conc6)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-statement-conc6 (b* ((abnf::cstss (cst-statement-conc6 abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::cstss (cst-statement-conc6 abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "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"))) (let ((__function__ 'cst-compound-statement-conc)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-block-item-conc1)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-block-item-conc2)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-expression-statement-conc)) (declare (ignorable __function__)) (abnf::tree-nonleaf->branches abnf::cst)))
Theorem:
(defthm tree-list-listp-of-cst-expression-statement-conc (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst))) (abnf::tree-list-listp abnf::cstss)) :rule-classes :rewrite)
Theorem:
(defthm cst-expression-statement-conc-match (implies (cst-matchp abnf::cst "expression-statement") (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst))) (cst-list-list-conc-matchp abnf::cstss "[ 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)))) (let ((__function__ 'cst-external-declaration-conc1)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-external-declaration-conc2)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-function-definition-conc)) (declare (ignorable __function__)) (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 "[ %s\"__extension__\" ] declaration-specifiers declarator [ declaration-list ] 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-uppercase-letter-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter"))) (let ((__function__ 'cst-uppercase-letter-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-uppercase-letter-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-uppercase-letter-conc-rep (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-rep-match (implies (cst-matchp abnf::cst "uppercase-letter") (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x41-5A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-rep-of-tree-fix-cst (equal (cst-uppercase-letter-conc-rep (abnf::tree-fix abnf::cst)) (cst-uppercase-letter-conc-rep abnf::cst)))
Theorem:
(defthm cst-uppercase-letter-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-uppercase-letter-conc-rep abnf::cst) (cst-uppercase-letter-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lowercase-letter-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter"))) (let ((__function__ 'cst-lowercase-letter-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-lowercase-letter-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-lowercase-letter-conc-rep (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-rep-match (implies (cst-matchp abnf::cst "lowercase-letter") (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x61-7A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-rep-of-tree-fix-cst (equal (cst-lowercase-letter-conc-rep (abnf::tree-fix abnf::cst)) (cst-lowercase-letter-conc-rep abnf::cst)))
Theorem:
(defthm cst-lowercase-letter-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lowercase-letter-conc-rep abnf::cst) (cst-lowercase-letter-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)))) (let ((__function__ 'cst-letter-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-letter-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-letter-conc1-rep (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-rep-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "uppercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-rep-of-tree-fix-cst (equal (cst-letter-conc1-rep (abnf::tree-fix abnf::cst)) (cst-letter-conc1-rep abnf::cst)))
Theorem:
(defthm cst-letter-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc1-rep abnf::cst) (cst-letter-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)))) (let ((__function__ 'cst-letter-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-letter-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-letter-conc2-rep (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-rep-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "lowercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-rep-of-tree-fix-cst (equal (cst-letter-conc2-rep (abnf::tree-fix abnf::cst)) (cst-letter-conc2-rep abnf::cst)))
Theorem:
(defthm cst-letter-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc2-rep abnf::cst) (cst-letter-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-digit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "digit"))) (let ((__function__ 'cst-digit-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-digit-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-digit-conc-rep (b* ((abnf::csts (cst-digit-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-rep-match (implies (cst-matchp abnf::cst "digit") (b* ((abnf::csts (cst-digit-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-rep-of-tree-fix-cst (equal (cst-digit-conc-rep (abnf::tree-fix abnf::cst)) (cst-digit-conc-rep abnf::cst)))
Theorem:
(defthm cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-digit-conc-rep abnf::cst) (cst-digit-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"))) (let ((__function__ 'cst-double-quote-conc-rep)) (declare (ignorable __function__)) (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-space-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (let ((__function__ 'cst-space-conc-rep)) (declare (ignorable __function__)) (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-horizontal-tab-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (let ((__function__ 'cst-horizontal-tab-conc-rep)) (declare (ignorable __function__)) (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-vertical-tab-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (let ((__function__ 'cst-vertical-tab-conc-rep)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-form-feed-conc-rep)) (declare (ignorable __function__)) (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-control-character-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-control-character-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-control-character-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-control-character-conc1-rep (b* ((abnf::csts (cst-control-character-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-rep-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-control-character-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-rep-of-tree-fix-cst (equal (cst-control-character-conc1-rep (abnf::tree-fix abnf::cst)) (cst-control-character-conc1-rep abnf::cst)))
Theorem:
(defthm cst-control-character-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc1-rep abnf::cst) (cst-control-character-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-control-character-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-control-character-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-control-character-conc2-rep (b* ((abnf::csts (cst-control-character-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-rep-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-control-character-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-rep-of-tree-fix-cst (equal (cst-control-character-conc2-rep (abnf::tree-fix abnf::cst)) (cst-control-character-conc2-rep abnf::cst)))
Theorem:
(defthm cst-control-character-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc2-rep abnf::cst) (cst-control-character-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-control-character-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-control-character-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-control-character-conc3-rep (b* ((abnf::csts (cst-control-character-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-rep-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-control-character-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-rep-of-tree-fix-cst (equal (cst-control-character-conc3-rep (abnf::tree-fix abnf::cst)) (cst-control-character-conc3-rep abnf::cst)))
Theorem:
(defthm cst-control-character-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc3-rep abnf::cst) (cst-control-character-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-conc1-rep (b* ((abnf::csts (cst-basic-character-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-rep-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-basic-character-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-rep-of-tree-fix-cst (equal (cst-basic-character-conc1-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-conc1-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc1-rep abnf::cst) (cst-basic-character-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-conc2-rep (b* ((abnf::csts (cst-basic-character-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-rep-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-basic-character-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-rep-of-tree-fix-cst (equal (cst-basic-character-conc2-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-conc2-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc2-rep abnf::cst) (cst-basic-character-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-conc3-rep (b* ((abnf::csts (cst-basic-character-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-rep-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-basic-character-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "graphic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-rep-of-tree-fix-cst (equal (cst-basic-character-conc3-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-conc3-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc3-rep abnf::cst) (cst-basic-character-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-conc4-rep (b* ((abnf::csts (cst-basic-character-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-rep-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-basic-character-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-rep-of-tree-fix-cst (equal (cst-basic-character-conc4-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-conc4-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc4-rep abnf::cst) (cst-basic-character-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-conc5-rep (b* ((abnf::csts (cst-basic-character-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-rep-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-basic-character-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-rep-of-tree-fix-cst (equal (cst-basic-character-conc5-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-conc5-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc5-rep abnf::cst) (cst-basic-character-conc5-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"))) (let ((__function__ 'cst-line-feed-conc-rep)) (declare (ignorable __function__)) (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-carriage-return-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (let ((__function__ 'cst-carriage-return-conc-rep)) (declare (ignorable __function__)) (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-character-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-conc1-rep (b* ((abnf::csts (cst-character-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-rep-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-rep-of-tree-fix-cst (equal (cst-character-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc1-rep abnf::cst) (cst-character-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-conc2-rep (b* ((abnf::csts (cst-character-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-rep-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-rep-of-tree-fix-cst (equal (cst-character-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc2-rep abnf::cst) (cst-character-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-conc1-rep (b* ((abnf::csts (cst-basic-character-not-star-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-basic-character-not-star-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-conc1-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc1-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc1-rep abnf::cst) (cst-basic-character-not-star-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-conc2-rep (b* ((abnf::csts (cst-basic-character-not-star-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-basic-character-not-star-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-conc2-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc2-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc2-rep abnf::cst) (cst-basic-character-not-star-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-conc3-rep (b* ((abnf::csts (cst-basic-character-not-star-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-basic-character-not-star-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "graphic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-conc3-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc3-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc3-rep abnf::cst) (cst-basic-character-not-star-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-conc4-rep (b* ((abnf::csts (cst-basic-character-not-star-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-basic-character-not-star-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-conc4-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc4-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc4-rep abnf::cst) (cst-basic-character-not-star-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-conc5-rep (b* ((abnf::csts (cst-basic-character-not-star-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-basic-character-not-star-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-conc5-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc5-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc5-rep abnf::cst) (cst-basic-character-not-star-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-or-slash-conc1-rep (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc1-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst) (cst-basic-character-not-star-or-slash-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-or-slash-conc2-rep (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc2-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst) (cst-basic-character-not-star-or-slash-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-or-slash-conc3-rep (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "graphic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc3-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst) (cst-basic-character-not-star-or-slash-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-or-slash-conc4-rep (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc4-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst) (cst-basic-character-not-star-or-slash-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-star-or-slash-conc5-rep (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc5-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst) (cst-basic-character-not-star-or-slash-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc1-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc2-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "graphic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc3-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc4-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc5-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc1-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc2-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "graphic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc3-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc4-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc5-rep abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-new-line-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-new-line-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-new-line-conc1-rep (b* ((abnf::csts (cst-character-not-new-line-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-rep-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-not-new-line-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-rep-of-tree-fix-cst (equal (cst-character-not-new-line-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc1-rep abnf::cst) (cst-character-not-new-line-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-new-line-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-new-line-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-new-line-conc2-rep (b* ((abnf::csts (cst-character-not-new-line-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-rep-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-not-new-line-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-rep-of-tree-fix-cst (equal (cst-character-not-new-line-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc2-rep abnf::cst) (cst-character-not-new-line-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-star-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-star-conc1-rep (b* ((abnf::csts (cst-character-not-star-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-rep-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-not-star-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-rep-of-tree-fix-cst (equal (cst-character-not-star-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc1-rep abnf::cst) (cst-character-not-star-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-star-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-star-conc2-rep (b* ((abnf::csts (cst-character-not-star-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-rep-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-not-star-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-rep-of-tree-fix-cst (equal (cst-character-not-star-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc2-rep abnf::cst) (cst-character-not-star-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-or-slash-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-star-or-slash-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-star-or-slash-conc1-rep (b* ((abnf::csts (cst-character-not-star-or-slash-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-not-star-or-slash-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc1-rep abnf::cst) (cst-character-not-star-or-slash-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-or-slash-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-star-or-slash-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-star-or-slash-conc2-rep (b* ((abnf::csts (cst-character-not-star-or-slash-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-not-star-or-slash-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc2-rep abnf::cst) (cst-character-not-star-or-slash-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-single-quote-or-backslash-or-new-line-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-single-quote-or-backslash-or-new-line-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-double-quote-or-backslash-or-new-line-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "basic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-character-not-double-quote-or-backslash-or-new-line-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-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)))) (let ((__function__ 'cst-white-space-conc1-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc2-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc3-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc4-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc5-rep)) (declare (ignorable __function__)) (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-comment-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-comment-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-comment-conc1-rep (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-comment-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-comment-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-comment-conc2-rep (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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-token-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc1-rep (b* ((abnf::csts (cst-token-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-token-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-token-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc2-rep (b* ((abnf::csts (cst-token-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-token-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-token-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc3-rep (b* ((abnf::csts (cst-token-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-token-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-token-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc4-rep (b* ((abnf::csts (cst-token-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-token-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-of-tree-fix-cst (equal (cst-token-conc4-rep (abnf::tree-fix abnf::cst)) (cst-token-conc4-rep abnf::cst)))
Theorem:
(defthm cst-token-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4-rep abnf::cst) (cst-token-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-token-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-token-conc5-rep (b* ((abnf::csts (cst-token-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-token-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "punctuator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-of-tree-fix-cst (equal (cst-token-conc5-rep (abnf::tree-fix abnf::cst)) (cst-token-conc5-rep abnf::cst)))
Theorem:
(defthm cst-token-conc5-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5-rep abnf::cst) (cst-token-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-nondigit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (let ((__function__ 'cst-identifier-nondigit-conc-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-constant-conc1-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-constant-conc2-rep)) (declare (ignorable __function__)) (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 "floating-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-constant-conc3-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) 3)))) (let ((__function__ 'cst-constant-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-constant-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-constant-conc3-rep (b* ((abnf::csts (cst-constant-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-rep-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-constant-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-rep-of-tree-fix-cst (equal (cst-constant-conc3-rep (abnf::tree-fix abnf::cst)) (cst-constant-conc3-rep abnf::cst)))
Theorem:
(defthm cst-constant-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc3-rep abnf::cst) (cst-constant-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc4-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) 4)))) (let ((__function__ 'cst-constant-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-constant-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-constant-conc4-rep (b* ((abnf::csts (cst-constant-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-rep-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-constant-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "character-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-rep-of-tree-fix-cst (equal (cst-constant-conc4-rep (abnf::tree-fix abnf::cst)) (cst-constant-conc4-rep abnf::cst)))
Theorem:
(defthm cst-constant-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc4-rep abnf::cst) (cst-constant-conc4-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"))) (let ((__function__ 'cst-hexadecimal-prefix-conc-rep)) (declare (ignorable __function__)) (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-nonzero-digit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit"))) (let ((__function__ 'cst-nonzero-digit-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-nonzero-digit-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-nonzero-digit-conc-rep (b* ((abnf::csts (cst-nonzero-digit-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-rep-match (implies (cst-matchp abnf::cst "nonzero-digit") (b* ((abnf::csts (cst-nonzero-digit-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-rep-of-tree-fix-cst (equal (cst-nonzero-digit-conc-rep (abnf::tree-fix abnf::cst)) (cst-nonzero-digit-conc-rep abnf::cst)))
Theorem:
(defthm cst-nonzero-digit-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-nonzero-digit-conc-rep abnf::cst) (cst-nonzero-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-octal-digit-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "octal-digit"))) (let ((__function__ 'cst-octal-digit-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-octal-digit-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-octal-digit-conc-rep (b* ((abnf::csts (cst-octal-digit-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-rep-match (implies (cst-matchp abnf::cst "octal-digit") (b* ((abnf::csts (cst-octal-digit-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "%x30-37"))) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-rep-of-tree-fix-cst (equal (cst-octal-digit-conc-rep (abnf::tree-fix abnf::cst)) (cst-octal-digit-conc-rep abnf::cst)))
Theorem:
(defthm cst-octal-digit-conc-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-octal-digit-conc-rep abnf::cst) (cst-octal-digit-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"))) (let ((__function__ 'cst-unsigned-suffix-conc-rep)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-long-suffix-conc-rep)) (declare (ignorable __function__)) (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-floating-constant-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-constant-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-floating-constant-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-floating-constant-conc1-rep (b* ((abnf::csts (cst-floating-constant-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-rep-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-floating-constant-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "decimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-rep-of-tree-fix-cst (equal (cst-floating-constant-conc1-rep (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc1-rep abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc1-rep abnf::cst) (cst-floating-constant-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-constant-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-constant-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-floating-constant-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-floating-constant-conc2-rep (b* ((abnf::csts (cst-floating-constant-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-rep-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-floating-constant-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "hexadecimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-rep-of-tree-fix-cst (equal (cst-floating-constant-conc2-rep (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc2-rep abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc2-rep abnf::cst) (cst-floating-constant-conc2-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"))) (let ((__function__ 'cst-enumeration-constant-conc-rep)) (declare (ignorable __function__)) (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-c-char-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-c-char-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-c-char-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-c-char-conc1-rep (b* ((abnf::csts (cst-c-char-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-rep-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-c-char-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "character-not-single-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-rep-of-tree-fix-cst (equal (cst-c-char-conc1-rep (abnf::tree-fix abnf::cst)) (cst-c-char-conc1-rep abnf::cst)))
Theorem:
(defthm cst-c-char-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc1-rep abnf::cst) (cst-c-char-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-c-char-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-c-char-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-c-char-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-c-char-conc2-rep (b* ((abnf::csts (cst-c-char-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-rep-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-c-char-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-rep-of-tree-fix-cst (equal (cst-c-char-conc2-rep (abnf::tree-fix abnf::cst)) (cst-c-char-conc2-rep abnf::cst)))
Theorem:
(defthm cst-c-char-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc2-rep abnf::cst) (cst-c-char-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)))) (let ((__function__ 'cst-escape-sequence-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-escape-sequence-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-escape-sequence-conc1-rep (b* ((abnf::csts (cst-escape-sequence-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-rep-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-escape-sequence-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "simple-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-rep-of-tree-fix-cst (equal (cst-escape-sequence-conc1-rep (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc1-rep abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc1-rep abnf::cst) (cst-escape-sequence-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)))) (let ((__function__ 'cst-escape-sequence-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-escape-sequence-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-escape-sequence-conc2-rep (b* ((abnf::csts (cst-escape-sequence-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-rep-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-escape-sequence-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "octal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-rep-of-tree-fix-cst (equal (cst-escape-sequence-conc2-rep (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc2-rep abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc2-rep abnf::cst) (cst-escape-sequence-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc3-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)))) (let ((__function__ 'cst-escape-sequence-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-escape-sequence-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-escape-sequence-conc3-rep (b* ((abnf::csts (cst-escape-sequence-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-rep-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-escape-sequence-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "hexadecimal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-rep-of-tree-fix-cst (equal (cst-escape-sequence-conc3-rep (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc3-rep abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc3-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc3-rep abnf::cst) (cst-escape-sequence-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc4-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)))) (let ((__function__ 'cst-escape-sequence-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-escape-sequence-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-escape-sequence-conc4-rep (b* ((abnf::csts (cst-escape-sequence-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-rep-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-escape-sequence-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "universal-character-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-rep-of-tree-fix-cst (equal (cst-escape-sequence-conc4-rep (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc4-rep abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc4-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc4-rep abnf::cst) (cst-escape-sequence-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc1-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-s-char-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-s-char-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-s-char-conc1-rep (b* ((abnf::csts (cst-s-char-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-rep-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-s-char-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "character-not-double-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-rep-of-tree-fix-cst (equal (cst-s-char-conc1-rep (abnf::tree-fix abnf::cst)) (cst-s-char-conc1-rep abnf::cst)))
Theorem:
(defthm cst-s-char-conc1-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc1-rep abnf::cst) (cst-s-char-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc2-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-s-char-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-s-char-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-s-char-conc2-rep (b* ((abnf::csts (cst-s-char-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-rep-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-s-char-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-rep-of-tree-fix-cst (equal (cst-s-char-conc2-rep (abnf::tree-fix abnf::cst)) (cst-s-char-conc2-rep abnf::cst)))
Theorem:
(defthm cst-s-char-conc2-rep-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc2-rep abnf::cst) (cst-s-char-conc2-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)))) (let ((__function__ 'cst-lexeme-conc1-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc2-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc3-rep)) (declare (ignorable __function__)) (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-constant-expression-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-constant-expression-conc abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-constant-expression-conc-rep (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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-typedef-name-conc-rep (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "typedef-name"))) (let ((__function__ 'cst-typedef-name-conc-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-statement-conc1-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc1 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc1-rep (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-statement-conc2-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc2 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc2-rep (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-statement-conc3-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc3 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc3-rep (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-statement-conc4-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc4 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc4-rep (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-statement-conc5-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc5 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc5-rep (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-statement-conc6-rep)) (declare (ignorable __function__)) (abnf::tree-list-fix (nth 0 (cst-statement-conc6 abnf::cst)))))
Theorem:
(defthm tree-listp-of-cst-statement-conc6-rep (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst))) (abnf::tree-listp abnf::csts)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst))) (cst-list-rep-matchp abnf::csts "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)))) (let ((__function__ 'cst-block-item-conc1-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-block-item-conc2-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-external-declaration-conc1-rep)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-external-declaration-conc2-rep)) (declare (ignorable __function__)) (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-uppercase-letter-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter"))) (let ((__function__ 'cst-uppercase-letter-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-uppercase-letter-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-uppercase-letter-conc-rep-elem (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-rep-elem-match (implies (cst-matchp abnf::cst "uppercase-letter") (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x41-5A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-uppercase-letter-conc-rep-elem-of-tree-fix-cst (equal (cst-uppercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-uppercase-letter-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-uppercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-uppercase-letter-conc-rep-elem abnf::cst) (cst-uppercase-letter-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-lowercase-letter-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter"))) (let ((__function__ 'cst-lowercase-letter-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-lowercase-letter-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-lowercase-letter-conc-rep-elem (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-rep-elem-match (implies (cst-matchp abnf::cst "lowercase-letter") (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x61-7A"))) :rule-classes :rewrite)
Theorem:
(defthm cst-lowercase-letter-conc-rep-elem-of-tree-fix-cst (equal (cst-lowercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-lowercase-letter-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-lowercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-lowercase-letter-conc-rep-elem abnf::cst) (cst-lowercase-letter-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)))) (let ((__function__ 'cst-letter-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-letter-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-letter-conc1-rep-elem (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "uppercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc1-rep-elem-of-tree-fix-cst (equal (cst-letter-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-letter-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-letter-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc1-rep-elem abnf::cst) (cst-letter-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-letter-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)))) (let ((__function__ 'cst-letter-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-letter-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-letter-conc2-rep-elem (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "letter") (equal (cst-letter-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "lowercase-letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-letter-conc2-rep-elem-of-tree-fix-cst (equal (cst-letter-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-letter-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-letter-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-letter-conc2-rep-elem abnf::cst) (cst-letter-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-digit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "digit"))) (let ((__function__ 'cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-digit-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-digit-conc-rep-elem (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-rep-elem-match (implies (cst-matchp abnf::cst "digit") (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-digit-conc-rep-elem-of-tree-fix-cst (equal (cst-digit-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-digit-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-digit-conc-rep-elem abnf::cst) (cst-digit-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"))) (let ((__function__ 'cst-double-quote-conc-rep-elem)) (declare (ignorable __function__)) (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-space-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "space"))) (let ((__function__ 'cst-space-conc-rep-elem)) (declare (ignorable __function__)) (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-horizontal-tab-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab"))) (let ((__function__ 'cst-horizontal-tab-conc-rep-elem)) (declare (ignorable __function__)) (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-vertical-tab-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab"))) (let ((__function__ 'cst-vertical-tab-conc-rep-elem)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-form-feed-conc-rep-elem)) (declare (ignorable __function__)) (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-control-character-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-control-character-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-control-character-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-control-character-conc1-rep-elem (b* ((abnf::cst1 (cst-control-character-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-control-character-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "horizontal-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc1-rep-elem-of-tree-fix-cst (equal (cst-control-character-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-control-character-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-control-character-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc1-rep-elem abnf::cst) (cst-control-character-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-control-character-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-control-character-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-control-character-conc2-rep-elem (b* ((abnf::cst1 (cst-control-character-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-control-character-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "vertical-tab"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc2-rep-elem-of-tree-fix-cst (equal (cst-control-character-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-control-character-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-control-character-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc2-rep-elem abnf::cst) (cst-control-character-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-control-character-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-control-character-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-control-character-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-control-character-conc3-rep-elem (b* ((abnf::cst1 (cst-control-character-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "control-character") (equal (cst-control-character-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-control-character-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "form-feed"))) :rule-classes :rewrite)
Theorem:
(defthm cst-control-character-conc3-rep-elem-of-tree-fix-cst (equal (cst-control-character-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-control-character-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-control-character-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-control-character-conc3-rep-elem abnf::cst) (cst-control-character-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-conc1-rep-elem (b* ((abnf::cst1 (cst-basic-character-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-basic-character-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc1-rep-elem-of-tree-fix-cst (equal (cst-basic-character-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc1-rep-elem abnf::cst) (cst-basic-character-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-conc2-rep-elem (b* ((abnf::cst1 (cst-basic-character-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-basic-character-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc2-rep-elem-of-tree-fix-cst (equal (cst-basic-character-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc2-rep-elem abnf::cst) (cst-basic-character-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-conc3-rep-elem (b* ((abnf::cst1 (cst-basic-character-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-basic-character-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "graphic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc3-rep-elem-of-tree-fix-cst (equal (cst-basic-character-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc3-rep-elem abnf::cst) (cst-basic-character-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-conc4-rep-elem (b* ((abnf::cst1 (cst-basic-character-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-basic-character-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc4-rep-elem-of-tree-fix-cst (equal (cst-basic-character-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc4-rep-elem abnf::cst) (cst-basic-character-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-conc5-rep-elem (b* ((abnf::cst1 (cst-basic-character-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character") (equal (cst-basic-character-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-basic-character-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-conc5-rep-elem-of-tree-fix-cst (equal (cst-basic-character-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-conc5-rep-elem abnf::cst) (cst-basic-character-conc5-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"))) (let ((__function__ 'cst-line-feed-conc-rep-elem)) (declare (ignorable __function__)) (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-carriage-return-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "carriage-return"))) (let ((__function__ 'cst-carriage-return-conc-rep-elem)) (declare (ignorable __function__)) (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-character-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-conc1-rep-elem (b* ((abnf::cst1 (cst-character-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc1-rep-elem abnf::cst) (cst-character-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-conc2-rep-elem (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character") (equal (cst-character-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-conc2-rep-elem abnf::cst) (cst-character-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-conc1-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-basic-character-not-star-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc1-rep-elem abnf::cst) (cst-basic-character-not-star-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-conc2-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-basic-character-not-star-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc2-rep-elem abnf::cst) (cst-basic-character-not-star-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-conc3-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-basic-character-not-star-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "graphic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc3-rep-elem abnf::cst) (cst-basic-character-not-star-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-conc4-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-basic-character-not-star-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc4-rep-elem abnf::cst) (cst-basic-character-not-star-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-conc5-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star") (equal (cst-basic-character-not-star-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-basic-character-not-star-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-conc5-rep-elem abnf::cst) (cst-basic-character-not-star-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-or-slash-conc1-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst) (cst-basic-character-not-star-or-slash-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-or-slash-conc2-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst) (cst-basic-character-not-star-or-slash-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-or-slash-conc3-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "graphic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst) (cst-basic-character-not-star-or-slash-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-or-slash-conc4-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst) (cst-basic-character-not-star-or-slash-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-star-or-slash-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-star-or-slash-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-star-or-slash-conc5-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-star-or-slash") (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-star-or-slash-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-star-or-slash-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst) (cst-basic-character-not-star-or-slash-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "graphic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-single-quote-or-backslash-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-single-quote-or-backslash") (equal (cst-basic-character-not-single-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem abnf::cst) (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "letter"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "graphic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "space"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)))) (let ((__function__ 'cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-basic-character-not-double-quote-or-backslash-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "basic-character-not-double-quote-or-backslash") (equal (cst-basic-character-not-double-quote-or-backslash-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "control-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem abnf::cst) (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-new-line-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-new-line-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-new-line-conc1-rep-elem (b* ((abnf::cst1 (cst-character-not-new-line-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-not-new-line-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-not-new-line-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc1-rep-elem abnf::cst) (cst-character-not-new-line-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-new-line-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-new-line-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-new-line-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-new-line-conc2-rep-elem (b* ((abnf::cst1 (cst-character-not-new-line-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-new-line") (equal (cst-character-not-new-line-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-not-new-line-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-new-line-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-not-new-line-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-new-line-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-new-line-conc2-rep-elem abnf::cst) (cst-character-not-new-line-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-star-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-star-conc1-rep-elem (b* ((abnf::cst1 (cst-character-not-star-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-not-star-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character-not-star"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-not-star-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc1-rep-elem abnf::cst) (cst-character-not-star-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-star-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-star-conc2-rep-elem (b* ((abnf::cst1 (cst-character-not-star-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-star") (equal (cst-character-not-star-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-not-star-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-not-star-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-star-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-conc2-rep-elem abnf::cst) (cst-character-not-star-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-star-or-slash-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-star-or-slash-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-star-or-slash-conc1-rep-elem (b* ((abnf::cst1 (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character-not-star-or-slash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst) (cst-character-not-star-or-slash-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-star-or-slash-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-star-or-slash-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-star-or-slash-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-star-or-slash-conc2-rep-elem (b* ((abnf::cst1 (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-star-or-slash") (equal (cst-character-not-star-or-slash-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-not-star-or-slash-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst) (cst-character-not-star-or-slash-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character-not-single-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-single-quote-or-backslash-or-new-line") (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst) (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "basic-character-not-double-quote-or-backslash"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)))) (let ((__function__ 'cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "character-not-double-quote-or-backslash-or-new-line") (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "extended-character-not-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem abnf::cst) (cst-character-not-double-quote-or-backslash-or-new-line-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)))) (let ((__function__ 'cst-white-space-conc1-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc2-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc3-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc4-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-white-space-conc5-rep-elem)) (declare (ignorable __function__)) (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-comment-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)))) (let ((__function__ 'cst-comment-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-comment-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-comment-conc1-rep-elem (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-comment-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-comment-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-comment-conc2-rep-elem (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-comment-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "comment") (equal (cst-comment-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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-token-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)))) (let ((__function__ 'cst-token-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc1-rep-elem (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-token-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc2-rep-elem (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-token-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc3-rep-elem (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-token-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc4-rep-elem (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "string-literal"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc4-rep-elem-of-tree-fix-cst (equal (cst-token-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc4-rep-elem abnf::cst) (cst-token-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-token-conc5-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)))) (let ((__function__ 'cst-token-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-token-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-token-conc5-rep-elem (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "token") (equal (cst-token-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "punctuator"))) :rule-classes :rewrite)
Theorem:
(defthm cst-token-conc5-rep-elem-of-tree-fix-cst (equal (cst-token-conc5-rep-elem (abnf::tree-fix abnf::cst)) (cst-token-conc5-rep-elem abnf::cst)))
Theorem:
(defthm cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-token-conc5-rep-elem abnf::cst) (cst-token-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-identifier-nondigit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "identifier-nondigit"))) (let ((__function__ 'cst-identifier-nondigit-conc-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-constant-conc1-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-constant-conc2-rep-elem)) (declare (ignorable __function__)) (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 "floating-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-constant-conc3-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) 3)))) (let ((__function__ 'cst-constant-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-constant-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-constant-conc3-rep-elem (b* ((abnf::cst1 (cst-constant-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-constant-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "enumeration-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc3-rep-elem-of-tree-fix-cst (equal (cst-constant-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-constant-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-constant-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc3-rep-elem abnf::cst) (cst-constant-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-constant-conc4-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) 4)))) (let ((__function__ 'cst-constant-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-constant-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-constant-conc4-rep-elem (b* ((abnf::cst1 (cst-constant-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "constant") (equal (cst-constant-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-constant-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "character-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-conc4-rep-elem-of-tree-fix-cst (equal (cst-constant-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-constant-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-constant-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-constant-conc4-rep-elem abnf::cst) (cst-constant-conc4-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"))) (let ((__function__ 'cst-hexadecimal-prefix-conc-rep-elem)) (declare (ignorable __function__)) (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-nonzero-digit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit"))) (let ((__function__ 'cst-nonzero-digit-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-nonzero-digit-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-nonzero-digit-conc-rep-elem (b* ((abnf::cst1 (cst-nonzero-digit-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-rep-elem-match (implies (cst-matchp abnf::cst "nonzero-digit") (b* ((abnf::cst1 (cst-nonzero-digit-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm cst-nonzero-digit-conc-rep-elem-of-tree-fix-cst (equal (cst-nonzero-digit-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-nonzero-digit-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-nonzero-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-nonzero-digit-conc-rep-elem abnf::cst) (cst-nonzero-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-octal-digit-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "octal-digit"))) (let ((__function__ 'cst-octal-digit-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-octal-digit-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-octal-digit-conc-rep-elem (b* ((abnf::cst1 (cst-octal-digit-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-rep-elem-match (implies (cst-matchp abnf::cst "octal-digit") (b* ((abnf::cst1 (cst-octal-digit-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "%x30-37"))) :rule-classes :rewrite)
Theorem:
(defthm cst-octal-digit-conc-rep-elem-of-tree-fix-cst (equal (cst-octal-digit-conc-rep-elem (abnf::tree-fix abnf::cst)) (cst-octal-digit-conc-rep-elem abnf::cst)))
Theorem:
(defthm cst-octal-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-octal-digit-conc-rep-elem abnf::cst) (cst-octal-digit-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"))) (let ((__function__ 'cst-unsigned-suffix-conc-rep-elem)) (declare (ignorable __function__)) (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"))) (let ((__function__ 'cst-long-suffix-conc-rep-elem)) (declare (ignorable __function__)) (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-floating-constant-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)))) (let ((__function__ 'cst-floating-constant-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-floating-constant-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-floating-constant-conc1-rep-elem (b* ((abnf::cst1 (cst-floating-constant-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-floating-constant-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "decimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc1-rep-elem-of-tree-fix-cst (equal (cst-floating-constant-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc1-rep-elem abnf::cst) (cst-floating-constant-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-floating-constant-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)))) (let ((__function__ 'cst-floating-constant-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-floating-constant-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-floating-constant-conc2-rep-elem (b* ((abnf::cst1 (cst-floating-constant-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "floating-constant") (equal (cst-floating-constant-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-floating-constant-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "hexadecimal-floating-constant"))) :rule-classes :rewrite)
Theorem:
(defthm cst-floating-constant-conc2-rep-elem-of-tree-fix-cst (equal (cst-floating-constant-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-floating-constant-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-floating-constant-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-floating-constant-conc2-rep-elem abnf::cst) (cst-floating-constant-conc2-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"))) (let ((__function__ 'cst-enumeration-constant-conc-rep-elem)) (declare (ignorable __function__)) (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-c-char-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-c-char-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-c-char-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-c-char-conc1-rep-elem (b* ((abnf::cst1 (cst-c-char-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-c-char-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "character-not-single-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc1-rep-elem-of-tree-fix-cst (equal (cst-c-char-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-c-char-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-c-char-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc1-rep-elem abnf::cst) (cst-c-char-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-c-char-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-c-char-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-c-char-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-c-char-conc2-rep-elem (b* ((abnf::cst1 (cst-c-char-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "c-char") (equal (cst-c-char-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-c-char-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-c-char-conc2-rep-elem-of-tree-fix-cst (equal (cst-c-char-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-c-char-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-c-char-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-c-char-conc2-rep-elem abnf::cst) (cst-c-char-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)))) (let ((__function__ 'cst-escape-sequence-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-escape-sequence-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-escape-sequence-conc1-rep-elem (b* ((abnf::cst1 (cst-escape-sequence-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-escape-sequence-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "simple-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc1-rep-elem-of-tree-fix-cst (equal (cst-escape-sequence-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc1-rep-elem abnf::cst) (cst-escape-sequence-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)))) (let ((__function__ 'cst-escape-sequence-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-escape-sequence-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-escape-sequence-conc2-rep-elem (b* ((abnf::cst1 (cst-escape-sequence-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-escape-sequence-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "octal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc2-rep-elem-of-tree-fix-cst (equal (cst-escape-sequence-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc2-rep-elem abnf::cst) (cst-escape-sequence-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc3-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)))) (let ((__function__ 'cst-escape-sequence-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-escape-sequence-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-escape-sequence-conc3-rep-elem (b* ((abnf::cst1 (cst-escape-sequence-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-escape-sequence-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "hexadecimal-escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc3-rep-elem-of-tree-fix-cst (equal (cst-escape-sequence-conc3-rep-elem (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc3-rep-elem abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc3-rep-elem abnf::cst) (cst-escape-sequence-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-escape-sequence-conc4-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)))) (let ((__function__ 'cst-escape-sequence-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-escape-sequence-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-escape-sequence-conc4-rep-elem (b* ((abnf::cst1 (cst-escape-sequence-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "escape-sequence") (equal (cst-escape-sequence-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-escape-sequence-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "universal-character-name"))) :rule-classes :rewrite)
Theorem:
(defthm cst-escape-sequence-conc4-rep-elem-of-tree-fix-cst (equal (cst-escape-sequence-conc4-rep-elem (abnf::tree-fix abnf::cst)) (cst-escape-sequence-conc4-rep-elem abnf::cst)))
Theorem:
(defthm cst-escape-sequence-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-escape-sequence-conc4-rep-elem abnf::cst) (cst-escape-sequence-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc1-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)))) (let ((__function__ 'cst-s-char-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-s-char-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-s-char-conc1-rep-elem (b* ((abnf::cst1 (cst-s-char-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-s-char-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "character-not-double-quote-or-backslash-or-new-line"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc1-rep-elem-of-tree-fix-cst (equal (cst-s-char-conc1-rep-elem (abnf::tree-fix abnf::cst)) (cst-s-char-conc1-rep-elem abnf::cst)))
Theorem:
(defthm cst-s-char-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc1-rep-elem abnf::cst) (cst-s-char-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun cst-s-char-conc2-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)))) (let ((__function__ 'cst-s-char-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-s-char-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-s-char-conc2-rep-elem (b* ((abnf::cst1 (cst-s-char-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "s-char") (equal (cst-s-char-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-s-char-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "escape-sequence"))) :rule-classes :rewrite)
Theorem:
(defthm cst-s-char-conc2-rep-elem-of-tree-fix-cst (equal (cst-s-char-conc2-rep-elem (abnf::tree-fix abnf::cst)) (cst-s-char-conc2-rep-elem abnf::cst)))
Theorem:
(defthm cst-s-char-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (abnf::tree-equiv abnf::cst cst-equiv) (equal (cst-s-char-conc2-rep-elem abnf::cst) (cst-s-char-conc2-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)))) (let ((__function__ 'cst-lexeme-conc1-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc2-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-lexeme-conc3-rep-elem)) (declare (ignorable __function__)) (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-constant-expression-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "constant-expression"))) (let ((__function__ 'cst-constant-expression-conc-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-constant-expression-conc-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-constant-expression-conc-rep-elem (b* ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-constant-expression-conc-rep-elem-match (implies (cst-matchp abnf::cst "constant-expression") (b* ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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-typedef-name-conc-rep-elem (abnf::cst) (declare (xargs :guard (abnf::treep abnf::cst))) (declare (xargs :guard (cst-matchp abnf::cst "typedef-name"))) (let ((__function__ 'cst-typedef-name-conc-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-statement-conc1-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc1-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc1-rep-elem (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc1-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 1)) (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-statement-conc2-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc2-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc2-rep-elem (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc2-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 2)) (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-statement-conc3-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc3-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc3-rep-elem (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc3-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 3)) (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-statement-conc4-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc4-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc4-rep-elem (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc4-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 4)) (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-statement-conc5-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc5-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc5-rep-elem (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc5-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 5)) (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-statement-conc6-rep-elem)) (declare (ignorable __function__)) (abnf::tree-fix (nth 0 (cst-statement-conc6-rep abnf::cst)))))
Theorem:
(defthm treep-of-cst-statement-conc6-rep-elem (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst))) (abnf::treep abnf::cst1)) :rule-classes :rewrite)
Theorem:
(defthm cst-statement-conc6-rep-elem-match (implies (and (cst-matchp abnf::cst "statement") (equal (cst-statement-conc? abnf::cst) 6)) (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst))) (cst-matchp abnf::cst1 "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)))) (let ((__function__ 'cst-block-item-conc1-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-block-item-conc2-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-external-declaration-conc1-rep-elem)) (declare (ignorable __function__)) (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)))) (let ((__function__ 'cst-external-declaration-conc2-rep-elem)) (declare (ignorable __function__)) (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)