Tree operations specialized to *all-smtp-grammar-rules*.
Function:
(defun smtp-cst-matchp$ (tree elem) (declare (xargs :guard (and (treep tree) (elementp elem)))) (let ((__function__ 'smtp-cst-matchp$)) (declare (ignorable __function__)) (and (tree-terminatedp tree) (tree-match-element-p tree elem *all-smtp-grammar-rules*))))
Theorem:
(defthm booleanp-of-smtp-cst-matchp$ (b* ((yes/no (smtp-cst-matchp$ tree elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-matchp$-of-tree-fix-tree (equal (smtp-cst-matchp$ (tree-fix tree) elem) (smtp-cst-matchp$ tree elem)))
Theorem:
(defthm smtp-cst-matchp$-tree-equiv-congruence-on-tree (implies (tree-equiv tree tree-equiv) (equal (smtp-cst-matchp$ tree elem) (smtp-cst-matchp$ tree-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-matchp$-of-element-fix-elem (equal (smtp-cst-matchp$ tree (element-fix elem)) (smtp-cst-matchp$ tree elem)))
Theorem:
(defthm smtp-cst-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (smtp-cst-matchp$ tree elem) (smtp-cst-matchp$ tree elem-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-list-elem-matchp$ (trees elem) (declare (xargs :guard (and (tree-listp trees) (elementp elem)))) (let ((__function__ 'smtp-cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-element-p trees elem *all-smtp-grammar-rules*))))
Theorem:
(defthm booleanp-of-smtp-cst-list-elem-matchp$ (b* ((yes/no (smtp-cst-list-elem-matchp$ trees elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-list-elem-matchp$-of-tree-list-fix-trees (equal (smtp-cst-list-elem-matchp$ (tree-list-fix trees) elem) (smtp-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm smtp-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (smtp-cst-list-elem-matchp$ trees elem) (smtp-cst-list-elem-matchp$ trees-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-list-elem-matchp$-of-element-fix-elem (equal (smtp-cst-list-elem-matchp$ trees (element-fix elem)) (smtp-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm smtp-cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (smtp-cst-list-elem-matchp$ trees elem) (smtp-cst-list-elem-matchp$ trees elem-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-list-rep-matchp$ (trees rep) (declare (xargs :guard (and (tree-listp trees) (repetitionp rep)))) (let ((__function__ 'smtp-cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-repetition-p trees rep *all-smtp-grammar-rules*))))
Theorem:
(defthm booleanp-of-smtp-cst-list-rep-matchp$ (b* ((yes/no (smtp-cst-list-rep-matchp$ trees rep))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-list-rep-matchp$-of-tree-list-fix-trees (equal (smtp-cst-list-rep-matchp$ (tree-list-fix trees) rep) (smtp-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm smtp-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (smtp-cst-list-rep-matchp$ trees rep) (smtp-cst-list-rep-matchp$ trees-equiv rep))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-list-rep-matchp$-of-repetition-fix-rep (equal (smtp-cst-list-rep-matchp$ trees (repetition-fix rep)) (smtp-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm smtp-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (repetition-equiv rep rep-equiv) (equal (smtp-cst-list-rep-matchp$ trees rep) (smtp-cst-list-rep-matchp$ trees rep-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-list-list-conc-matchp$ (treess conc) (declare (xargs :guard (and (tree-list-listp treess) (concatenationp conc)))) (let ((__function__ 'smtp-cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-concatenation-p treess conc *all-smtp-grammar-rules*))))
Theorem:
(defthm booleanp-of-smtp-cst-list-list-conc-matchp$ (b* ((yes/no (smtp-cst-list-list-conc-matchp$ treess conc))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (smtp-cst-list-list-conc-matchp$ (tree-list-list-fix treess) conc) (smtp-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm smtp-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (smtp-cst-list-list-conc-matchp$ treess conc) (smtp-cst-list-list-conc-matchp$ treess-equiv conc))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (smtp-cst-list-list-conc-matchp$ treess (concatenation-fix conc)) (smtp-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm smtp-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (concatenation-equiv conc conc-equiv) (equal (smtp-cst-list-list-conc-matchp$ treess conc) (smtp-cst-list-list-conc-matchp$ treess conc-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-list-list-alt-matchp$ (treess alt) (declare (xargs :guard (and (tree-list-listp treess) (alternationp alt)))) (let ((__function__ 'smtp-cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-alternation-p treess alt *all-smtp-grammar-rules*))))
Theorem:
(defthm booleanp-of-smtp-cst-list-list-alt-matchp$ (b* ((yes/no (smtp-cst-list-list-alt-matchp$ treess alt))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (smtp-cst-list-list-alt-matchp$ (tree-list-list-fix treess) alt) (smtp-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm smtp-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (smtp-cst-list-list-alt-matchp$ treess alt) (smtp-cst-list-list-alt-matchp$ treess-equiv alt))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (smtp-cst-list-list-alt-matchp$ treess (alternation-fix alt)) (smtp-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm smtp-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (alternation-equiv alt alt-equiv) (equal (smtp-cst-list-list-alt-matchp$ treess alt) (smtp-cst-list-list-alt-matchp$ treess alt-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d0-9-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d0-9"))) (let ((__function__ 'smtp-cst-%d0-9-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d0-9-nat (b* ((nat (smtp-cst-%d0-9-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d0-9-nat-of-tree-fix-cst (equal (smtp-cst-%d0-9-nat (tree-fix cst)) (smtp-cst-%d0-9-nat cst)))
Theorem:
(defthm smtp-cst-%d0-9-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d0-9-nat cst) (smtp-cst-%d0-9-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d1-8-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d1-8"))) (let ((__function__ 'smtp-cst-%d1-8-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d1-8-nat (b* ((nat (smtp-cst-%d1-8-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d1-8-nat-of-tree-fix-cst (equal (smtp-cst-%d1-8-nat (tree-fix cst)) (smtp-cst-%d1-8-nat cst)))
Theorem:
(defthm smtp-cst-%d1-8-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d1-8-nat cst) (smtp-cst-%d1-8-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d11-12-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d11-12"))) (let ((__function__ 'smtp-cst-%d11-12-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d11-12-nat (b* ((nat (smtp-cst-%d11-12-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d11-12-nat-of-tree-fix-cst (equal (smtp-cst-%d11-12-nat (tree-fix cst)) (smtp-cst-%d11-12-nat cst)))
Theorem:
(defthm smtp-cst-%d11-12-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d11-12-nat cst) (smtp-cst-%d11-12-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d14-31-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d14-31"))) (let ((__function__ 'smtp-cst-%d14-31-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d14-31-nat (b* ((nat (smtp-cst-%d14-31-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d14-31-nat-of-tree-fix-cst (equal (smtp-cst-%d14-31-nat (tree-fix cst)) (smtp-cst-%d14-31-nat cst)))
Theorem:
(defthm smtp-cst-%d14-31-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d14-31-nat cst) (smtp-cst-%d14-31-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d14-127-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d14-127"))) (let ((__function__ 'smtp-cst-%d14-127-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d14-127-nat (b* ((nat (smtp-cst-%d14-127-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d14-127-nat-of-tree-fix-cst (equal (smtp-cst-%d14-127-nat (tree-fix cst)) (smtp-cst-%d14-127-nat cst)))
Theorem:
(defthm smtp-cst-%d14-127-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d14-127-nat cst) (smtp-cst-%d14-127-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d32-33-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d32-33"))) (let ((__function__ 'smtp-cst-%d32-33-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d32-33-nat (b* ((nat (smtp-cst-%d32-33-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d32-33-nat-of-tree-fix-cst (equal (smtp-cst-%d32-33-nat (tree-fix cst)) (smtp-cst-%d32-33-nat cst)))
Theorem:
(defthm smtp-cst-%d32-33-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d32-33-nat cst) (smtp-cst-%d32-33-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d32-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d32-126"))) (let ((__function__ 'smtp-cst-%d32-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d32-126-nat (b* ((nat (smtp-cst-%d32-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d32-126-nat-of-tree-fix-cst (equal (smtp-cst-%d32-126-nat (tree-fix cst)) (smtp-cst-%d32-126-nat cst)))
Theorem:
(defthm smtp-cst-%d32-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d32-126-nat cst) (smtp-cst-%d32-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d33-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d33-39"))) (let ((__function__ 'smtp-cst-%d33-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d33-39-nat (b* ((nat (smtp-cst-%d33-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d33-39-nat-of-tree-fix-cst (equal (smtp-cst-%d33-39-nat (tree-fix cst)) (smtp-cst-%d33-39-nat cst)))
Theorem:
(defthm smtp-cst-%d33-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d33-39-nat cst) (smtp-cst-%d33-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d33-60-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d33-60"))) (let ((__function__ 'smtp-cst-%d33-60-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d33-60-nat (b* ((nat (smtp-cst-%d33-60-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d33-60-nat-of-tree-fix-cst (equal (smtp-cst-%d33-60-nat (tree-fix cst)) (smtp-cst-%d33-60-nat cst)))
Theorem:
(defthm smtp-cst-%d33-60-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d33-60-nat cst) (smtp-cst-%d33-60-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d33-90-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d33-90"))) (let ((__function__ 'smtp-cst-%d33-90-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d33-90-nat (b* ((nat (smtp-cst-%d33-90-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d33-90-nat-of-tree-fix-cst (equal (smtp-cst-%d33-90-nat (tree-fix cst)) (smtp-cst-%d33-90-nat cst)))
Theorem:
(defthm smtp-cst-%d33-90-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d33-90-nat cst) (smtp-cst-%d33-90-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d33-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d33-126"))) (let ((__function__ 'smtp-cst-%d33-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d33-126-nat (b* ((nat (smtp-cst-%d33-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d33-126-nat-of-tree-fix-cst (equal (smtp-cst-%d33-126-nat (tree-fix cst)) (smtp-cst-%d33-126-nat cst)))
Theorem:
(defthm smtp-cst-%d33-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d33-126-nat cst) (smtp-cst-%d33-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d35-91-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d35-91"))) (let ((__function__ 'smtp-cst-%d35-91-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d35-91-nat (b* ((nat (smtp-cst-%d35-91-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d35-91-nat-of-tree-fix-cst (equal (smtp-cst-%d35-91-nat (tree-fix cst)) (smtp-cst-%d35-91-nat cst)))
Theorem:
(defthm smtp-cst-%d35-91-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d35-91-nat cst) (smtp-cst-%d35-91-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d42-91-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d42-91"))) (let ((__function__ 'smtp-cst-%d42-91-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d42-91-nat (b* ((nat (smtp-cst-%d42-91-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d42-91-nat-of-tree-fix-cst (equal (smtp-cst-%d42-91-nat (tree-fix cst)) (smtp-cst-%d42-91-nat cst)))
Theorem:
(defthm smtp-cst-%d42-91-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d42-91-nat cst) (smtp-cst-%d42-91-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d62-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d62-126"))) (let ((__function__ 'smtp-cst-%d62-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d62-126-nat (b* ((nat (smtp-cst-%d62-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d62-126-nat-of-tree-fix-cst (equal (smtp-cst-%d62-126-nat (tree-fix cst)) (smtp-cst-%d62-126-nat cst)))
Theorem:
(defthm smtp-cst-%d62-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d62-126-nat cst) (smtp-cst-%d62-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d65-73-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d65-73"))) (let ((__function__ 'smtp-cst-%d65-73-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d65-73-nat (b* ((nat (smtp-cst-%d65-73-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d65-73-nat-of-tree-fix-cst (equal (smtp-cst-%d65-73-nat (tree-fix cst)) (smtp-cst-%d65-73-nat cst)))
Theorem:
(defthm smtp-cst-%d65-73-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d65-73-nat cst) (smtp-cst-%d65-73-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d75-90-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d75-90"))) (let ((__function__ 'smtp-cst-%d75-90-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d75-90-nat (b* ((nat (smtp-cst-%d75-90-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d75-90-nat-of-tree-fix-cst (equal (smtp-cst-%d75-90-nat (tree-fix cst)) (smtp-cst-%d75-90-nat cst)))
Theorem:
(defthm smtp-cst-%d75-90-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d75-90-nat cst) (smtp-cst-%d75-90-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d93-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d93-126"))) (let ((__function__ 'smtp-cst-%d93-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d93-126-nat (b* ((nat (smtp-cst-%d93-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d93-126-nat-of-tree-fix-cst (equal (smtp-cst-%d93-126-nat (tree-fix cst)) (smtp-cst-%d93-126-nat cst)))
Theorem:
(defthm smtp-cst-%d93-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d93-126-nat cst) (smtp-cst-%d93-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d94-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d94-126"))) (let ((__function__ 'smtp-cst-%d94-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d94-126-nat (b* ((nat (smtp-cst-%d94-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d94-126-nat-of-tree-fix-cst (equal (smtp-cst-%d94-126-nat (tree-fix cst)) (smtp-cst-%d94-126-nat cst)))
Theorem:
(defthm smtp-cst-%d94-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d94-126-nat cst) (smtp-cst-%d94-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d97-105-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d97-105"))) (let ((__function__ 'smtp-cst-%d97-105-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d97-105-nat (b* ((nat (smtp-cst-%d97-105-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d97-105-nat-of-tree-fix-cst (equal (smtp-cst-%d97-105-nat (tree-fix cst)) (smtp-cst-%d97-105-nat cst)))
Theorem:
(defthm smtp-cst-%d97-105-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d97-105-nat cst) (smtp-cst-%d97-105-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%d107-122-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%d107-122"))) (let ((__function__ 'smtp-cst-%d107-122-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%d107-122-nat (b* ((nat (smtp-cst-%d107-122-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%d107-122-nat-of-tree-fix-cst (equal (smtp-cst-%d107-122-nat (tree-fix cst)) (smtp-cst-%d107-122-nat cst)))
Theorem:
(defthm smtp-cst-%d107-122-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%d107-122-nat cst) (smtp-cst-%d107-122-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x21-7e-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x21-7E"))) (let ((__function__ 'smtp-cst-%x21-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x21-7e-nat (b* ((nat (smtp-cst-%x21-7e-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x21-7e-nat-of-tree-fix-cst (equal (smtp-cst-%x21-7e-nat (tree-fix cst)) (smtp-cst-%x21-7e-nat cst)))
Theorem:
(defthm smtp-cst-%x21-7e-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x21-7e-nat cst) (smtp-cst-%x21-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x30-35-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x30-35"))) (let ((__function__ 'smtp-cst-%x30-35-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x30-35-nat (b* ((nat (smtp-cst-%x30-35-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x30-35-nat-of-tree-fix-cst (equal (smtp-cst-%x30-35-nat (tree-fix cst)) (smtp-cst-%x30-35-nat cst)))
Theorem:
(defthm smtp-cst-%x30-35-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x30-35-nat cst) (smtp-cst-%x30-35-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x30-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x30-39"))) (let ((__function__ 'smtp-cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x30-39-nat (b* ((nat (smtp-cst-%x30-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x30-39-nat-of-tree-fix-cst (equal (smtp-cst-%x30-39-nat (tree-fix cst)) (smtp-cst-%x30-39-nat cst)))
Theorem:
(defthm smtp-cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x30-39-nat cst) (smtp-cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x32-35-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x32-35"))) (let ((__function__ 'smtp-cst-%x32-35-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x32-35-nat (b* ((nat (smtp-cst-%x32-35-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x32-35-nat-of-tree-fix-cst (equal (smtp-cst-%x32-35-nat (tree-fix cst)) (smtp-cst-%x32-35-nat cst)))
Theorem:
(defthm smtp-cst-%x32-35-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x32-35-nat cst) (smtp-cst-%x32-35-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x41-5a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x41-5A"))) (let ((__function__ 'smtp-cst-%x41-5a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x41-5a-nat (b* ((nat (smtp-cst-%x41-5a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x41-5a-nat-of-tree-fix-cst (equal (smtp-cst-%x41-5a-nat (tree-fix cst)) (smtp-cst-%x41-5a-nat cst)))
Theorem:
(defthm smtp-cst-%x41-5a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x41-5a-nat cst) (smtp-cst-%x41-5a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-%x61-7a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "%x61-7A"))) (let ((__function__ 'smtp-cst-%x61-7a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-smtp-cst-%x61-7a-nat (b* ((nat (smtp-cst-%x61-7a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-%x61-7a-nat-of-tree-fix-cst (equal (smtp-cst-%x61-7a-nat (tree-fix cst)) (smtp-cst-%x61-7a-nat cst)))
Theorem:
(defthm smtp-cst-%x61-7a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-%x61-7a-nat cst) (smtp-cst-%x61-7a-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-%d0-9-nat-bounds (implies (smtp-cst-matchp cst "%d0-9") (and (<= 0 (smtp-cst-%d0-9-nat cst)) (<= (smtp-cst-%d0-9-nat cst) 9))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d1-8-nat-bounds (implies (smtp-cst-matchp cst "%d1-8") (and (<= 1 (smtp-cst-%d1-8-nat cst)) (<= (smtp-cst-%d1-8-nat cst) 8))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d11-12-nat-bounds (implies (smtp-cst-matchp cst "%d11-12") (and (<= 11 (smtp-cst-%d11-12-nat cst)) (<= (smtp-cst-%d11-12-nat cst) 12))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d14-31-nat-bounds (implies (smtp-cst-matchp cst "%d14-31") (and (<= 14 (smtp-cst-%d14-31-nat cst)) (<= (smtp-cst-%d14-31-nat cst) 31))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d14-127-nat-bounds (implies (smtp-cst-matchp cst "%d14-127") (and (<= 14 (smtp-cst-%d14-127-nat cst)) (<= (smtp-cst-%d14-127-nat cst) 127))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d32-33-nat-bounds (implies (smtp-cst-matchp cst "%d32-33") (and (<= 32 (smtp-cst-%d32-33-nat cst)) (<= (smtp-cst-%d32-33-nat cst) 33))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d32-126-nat-bounds (implies (smtp-cst-matchp cst "%d32-126") (and (<= 32 (smtp-cst-%d32-126-nat cst)) (<= (smtp-cst-%d32-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d33-39-nat-bounds (implies (smtp-cst-matchp cst "%d33-39") (and (<= 33 (smtp-cst-%d33-39-nat cst)) (<= (smtp-cst-%d33-39-nat cst) 39))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d33-60-nat-bounds (implies (smtp-cst-matchp cst "%d33-60") (and (<= 33 (smtp-cst-%d33-60-nat cst)) (<= (smtp-cst-%d33-60-nat cst) 60))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d33-90-nat-bounds (implies (smtp-cst-matchp cst "%d33-90") (and (<= 33 (smtp-cst-%d33-90-nat cst)) (<= (smtp-cst-%d33-90-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d33-126-nat-bounds (implies (smtp-cst-matchp cst "%d33-126") (and (<= 33 (smtp-cst-%d33-126-nat cst)) (<= (smtp-cst-%d33-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d35-91-nat-bounds (implies (smtp-cst-matchp cst "%d35-91") (and (<= 35 (smtp-cst-%d35-91-nat cst)) (<= (smtp-cst-%d35-91-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d42-91-nat-bounds (implies (smtp-cst-matchp cst "%d42-91") (and (<= 42 (smtp-cst-%d42-91-nat cst)) (<= (smtp-cst-%d42-91-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d62-126-nat-bounds (implies (smtp-cst-matchp cst "%d62-126") (and (<= 62 (smtp-cst-%d62-126-nat cst)) (<= (smtp-cst-%d62-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d65-73-nat-bounds (implies (smtp-cst-matchp cst "%d65-73") (and (<= 65 (smtp-cst-%d65-73-nat cst)) (<= (smtp-cst-%d65-73-nat cst) 73))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d75-90-nat-bounds (implies (smtp-cst-matchp cst "%d75-90") (and (<= 75 (smtp-cst-%d75-90-nat cst)) (<= (smtp-cst-%d75-90-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d93-126-nat-bounds (implies (smtp-cst-matchp cst "%d93-126") (and (<= 93 (smtp-cst-%d93-126-nat cst)) (<= (smtp-cst-%d93-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d94-126-nat-bounds (implies (smtp-cst-matchp cst "%d94-126") (and (<= 94 (smtp-cst-%d94-126-nat cst)) (<= (smtp-cst-%d94-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d97-105-nat-bounds (implies (smtp-cst-matchp cst "%d97-105") (and (<= 97 (smtp-cst-%d97-105-nat cst)) (<= (smtp-cst-%d97-105-nat cst) 105))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%d107-122-nat-bounds (implies (smtp-cst-matchp cst "%d107-122") (and (<= 107 (smtp-cst-%d107-122-nat cst)) (<= (smtp-cst-%d107-122-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x21-7e-nat-bounds (implies (smtp-cst-matchp cst "%x21-7E") (and (<= 33 (smtp-cst-%x21-7e-nat cst)) (<= (smtp-cst-%x21-7e-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x30-35-nat-bounds (implies (smtp-cst-matchp cst "%x30-35") (and (<= 48 (smtp-cst-%x30-35-nat cst)) (<= (smtp-cst-%x30-35-nat cst) 53))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x30-39-nat-bounds (implies (smtp-cst-matchp cst "%x30-39") (and (<= 48 (smtp-cst-%x30-39-nat cst)) (<= (smtp-cst-%x30-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x32-35-nat-bounds (implies (smtp-cst-matchp cst "%x32-35") (and (<= 50 (smtp-cst-%x32-35-nat cst)) (<= (smtp-cst-%x32-35-nat cst) 53))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x41-5a-nat-bounds (implies (smtp-cst-matchp cst "%x41-5A") (and (<= 65 (smtp-cst-%x41-5a-nat cst)) (<= (smtp-cst-%x41-5a-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm smtp-cst-%x61-7a-nat-bounds (implies (smtp-cst-matchp cst "%x61-7A") (and (<= 97 (smtp-cst-%x61-7a-nat cst)) (<= (smtp-cst-%x61-7a-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm |SMTP-CST-"!"-LEAFTERM| (implies (smtp-cst-matchp cst "\"!\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"#"-LEAFTERM| (implies (smtp-cst-matchp cst "\"#\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"$"-LEAFTERM| (implies (smtp-cst-matchp cst "\"$\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"%"-LEAFTERM| (implies (smtp-cst-matchp cst "\"%\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"&"-LEAFTERM| (implies (smtp-cst-matchp cst "\"&\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"'"-LEAFTERM| (implies (smtp-cst-matchp cst "\"'\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"("-LEAFTERM| (implies (smtp-cst-matchp cst "\"(\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-")"-LEAFTERM| (implies (smtp-cst-matchp cst "\")\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"*"-LEAFTERM| (implies (smtp-cst-matchp cst "\"*\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"+"-LEAFTERM| (implies (smtp-cst-matchp cst "\"+\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-","-LEAFTERM| (implies (smtp-cst-matchp cst "\",\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"-"-LEAFTERM| (implies (smtp-cst-matchp cst "\"-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"."-LEAFTERM| (implies (smtp-cst-matchp cst "\".\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"/"-LEAFTERM| (implies (smtp-cst-matchp cst "\"/\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"220"-LEAFTERM| (implies (smtp-cst-matchp cst "\"220\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"220 "-LEAFTERM| (implies (smtp-cst-matchp cst "\"220 \"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"220-"-LEAFTERM| (implies (smtp-cst-matchp cst "\"220-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"250"-LEAFTERM| (implies (smtp-cst-matchp cst "\"250\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"250-"-LEAFTERM| (implies (smtp-cst-matchp cst "\"250-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-":"-LEAFTERM| (implies (smtp-cst-matchp cst "\":\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"::"-LEAFTERM| (implies (smtp-cst-matchp cst "\"::\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-";"-LEAFTERM| (implies (smtp-cst-matchp cst "\";\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"<"-LEAFTERM| (implies (smtp-cst-matchp cst "\"<\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"<>"-LEAFTERM| (implies (smtp-cst-matchp cst "\"<>\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"<Postmaster>"-LEAFTERM| (implies (smtp-cst-matchp cst "\"<Postmaster>\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"<Postmaster@"-LEAFTERM| (implies (smtp-cst-matchp cst "\"<Postmaster@\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"="-LEAFTERM| (implies (smtp-cst-matchp cst "\"=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-">"-LEAFTERM| (implies (smtp-cst-matchp cst "\">\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"?"-LEAFTERM| (implies (smtp-cst-matchp cst "\"?\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"@"-LEAFTERM| (implies (smtp-cst-matchp cst "\"@\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"A"-LEAFTERM| (implies (smtp-cst-matchp cst "\"A\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Apr"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Apr\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Aug"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Aug\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"B"-LEAFTERM| (implies (smtp-cst-matchp cst "\"B\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"BY"-LEAFTERM| (implies (smtp-cst-matchp cst "\"BY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"C"-LEAFTERM| (implies (smtp-cst-matchp cst "\"C\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"CDT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"CDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"CST"-LEAFTERM| (implies (smtp-cst-matchp cst "\"CST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"D"-LEAFTERM| (implies (smtp-cst-matchp cst "\"D\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"DATA"-LEAFTERM| (implies (smtp-cst-matchp cst "\"DATA\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Dec"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Dec\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"E"-LEAFTERM| (implies (smtp-cst-matchp cst "\"E\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"EDT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"EDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"EHLO"-LEAFTERM| (implies (smtp-cst-matchp cst "\"EHLO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"ESMTP"-LEAFTERM| (implies (smtp-cst-matchp cst "\"ESMTP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"EST"-LEAFTERM| (implies (smtp-cst-matchp cst "\"EST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"EXPN"-LEAFTERM| (implies (smtp-cst-matchp cst "\"EXPN\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"F"-LEAFTERM| (implies (smtp-cst-matchp cst "\"F\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"FOR"-LEAFTERM| (implies (smtp-cst-matchp cst "\"FOR\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"FROM"-LEAFTERM| (implies (smtp-cst-matchp cst "\"FROM\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Feb"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Feb\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Fri"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Fri\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"GMT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"GMT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"HELO"-LEAFTERM| (implies (smtp-cst-matchp cst "\"HELO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"HELP"-LEAFTERM| (implies (smtp-cst-matchp cst "\"HELP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"ID"-LEAFTERM| (implies (smtp-cst-matchp cst "\"ID\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"IPv6:"-LEAFTERM| (implies (smtp-cst-matchp cst "\"IPv6:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Jan"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Jan\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Jul"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Jul\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Jun"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Jun\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"MAIL FROM:"-LEAFTERM| (implies (smtp-cst-matchp cst "\"MAIL FROM:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"MDT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"MDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"MST"-LEAFTERM| (implies (smtp-cst-matchp cst "\"MST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Mar"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Mar\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"May"-LEAFTERM| (implies (smtp-cst-matchp cst "\"May\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Mon"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Mon\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"NOOP"-LEAFTERM| (implies (smtp-cst-matchp cst "\"NOOP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Nov"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Nov\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Oct"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Oct\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"PDT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"PDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"PST"-LEAFTERM| (implies (smtp-cst-matchp cst "\"PST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"QUIT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"QUIT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"RCPT TO:"-LEAFTERM| (implies (smtp-cst-matchp cst "\"RCPT TO:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"RSET"-LEAFTERM| (implies (smtp-cst-matchp cst "\"RSET\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Received:"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Received:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Return-Path:"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Return-Path:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"SMTP"-LEAFTERM| (implies (smtp-cst-matchp cst "\"SMTP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Sat"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Sat\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Sep"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Sep\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Sun"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Sun\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"TCP"-LEAFTERM| (implies (smtp-cst-matchp cst "\"TCP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Thu"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Thu\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Tue"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Tue\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"UT"-LEAFTERM| (implies (smtp-cst-matchp cst "\"UT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"VIA"-LEAFTERM| (implies (smtp-cst-matchp cst "\"VIA\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"VRFY"-LEAFTERM| (implies (smtp-cst-matchp cst "\"VRFY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"WITH"-LEAFTERM| (implies (smtp-cst-matchp cst "\"WITH\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"Wed"-LEAFTERM| (implies (smtp-cst-matchp cst "\"Wed\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"["-LEAFTERM| (implies (smtp-cst-matchp cst "\"[\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"\\"-LEAFTERM| (implies (smtp-cst-matchp cst "\"\\\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"]"-LEAFTERM| (implies (smtp-cst-matchp cst "\"]\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"^"-LEAFTERM| (implies (smtp-cst-matchp cst "\"^\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"_"-LEAFTERM| (implies (smtp-cst-matchp cst "\"_\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"`"-LEAFTERM| (implies (smtp-cst-matchp cst "\"`\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"{"-LEAFTERM| (implies (smtp-cst-matchp cst "\"{\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"\|"-LEAFTERM| (implies (smtp-cst-matchp cst "\"|\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"}"-LEAFTERM| (implies (smtp-cst-matchp cst "\"}\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |SMTP-CST-"~"-LEAFTERM| (implies (smtp-cst-matchp cst "\"~\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm smtp-cst-ehlo-nonleaf (implies (smtp-cst-matchp cst "ehlo") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-helo-nonleaf (implies (smtp-cst-matchp cst "helo") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-nonleaf (implies (smtp-cst-matchp cst "ehlo-ok-rsp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-greet-nonleaf (implies (smtp-cst-matchp cst "ehlo-greet") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-line-nonleaf (implies (smtp-cst-matchp cst "ehlo-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-keyword-nonleaf (implies (smtp-cst-matchp cst "ehlo-keyword") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-param-nonleaf (implies (smtp-cst-matchp cst "ehlo-param") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-mail-nonleaf (implies (smtp-cst-matchp cst "mail") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-rcpt-nonleaf (implies (smtp-cst-matchp cst "rcpt") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-data-nonleaf (implies (smtp-cst-matchp cst "data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-rset-nonleaf (implies (smtp-cst-matchp cst "rset") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-vrfy-nonleaf (implies (smtp-cst-matchp cst "vrfy") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-expn-nonleaf (implies (smtp-cst-matchp cst "expn") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-help-nonleaf (implies (smtp-cst-matchp cst "help") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-noop-nonleaf (implies (smtp-cst-matchp cst "noop") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-quit-nonleaf (implies (smtp-cst-matchp cst "quit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-reverse-path-nonleaf (implies (smtp-cst-matchp cst "reverse-path") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-forward-path-nonleaf (implies (smtp-cst-matchp cst "forward-path") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-path-nonleaf (implies (smtp-cst-matchp cst "path") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-a-d-l-nonleaf (implies (smtp-cst-matchp cst "a-d-l") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-at-domain-nonleaf (implies (smtp-cst-matchp cst "at-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-mail-parameters-nonleaf (implies (smtp-cst-matchp cst "mail-parameters") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-rcpt-parameters-nonleaf (implies (smtp-cst-matchp cst "rcpt-parameters") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-esmtp-param-nonleaf (implies (smtp-cst-matchp cst "esmtp-param") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-esmtp-keyword-nonleaf (implies (smtp-cst-matchp cst "esmtp-keyword") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-esmtp-value-nonleaf (implies (smtp-cst-matchp cst "esmtp-value") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-keyword-nonleaf (implies (smtp-cst-matchp cst "keyword") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-argument-nonleaf (implies (smtp-cst-matchp cst "argument") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-domain-nonleaf (implies (smtp-cst-matchp cst "domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-sub-domain-nonleaf (implies (smtp-cst-matchp cst "sub-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-let-dig-nonleaf (implies (smtp-cst-matchp cst "let-dig") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ldh-str-nonleaf (implies (smtp-cst-matchp cst "ldh-str") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-address-literal-nonleaf (implies (smtp-cst-matchp cst "address-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-mailbox-nonleaf (implies (smtp-cst-matchp cst "mailbox") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-local-part-nonleaf (implies (smtp-cst-matchp cst "local-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dot-string-nonleaf (implies (smtp-cst-matchp cst "dot-string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-atom-nonleaf (implies (smtp-cst-matchp cst "atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-quoted-string-nonleaf (implies (smtp-cst-matchp cst "quoted-string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-qcontentsmtp-nonleaf (implies (smtp-cst-matchp cst "qcontentsmtp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-quoted-pairsmtp-nonleaf (implies (smtp-cst-matchp cst "quoted-pairsmtp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-qtextsmtp-nonleaf (implies (smtp-cst-matchp cst "qtextsmtp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-string-nonleaf (implies (smtp-cst-matchp cst "string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv4-address-literal-nonleaf (implies (smtp-cst-matchp cst "ipv4-address-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6-address-literal-nonleaf (implies (smtp-cst-matchp cst "ipv6-address-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-general-address-literal-nonleaf (implies (smtp-cst-matchp cst "general-address-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-standardized-tag-nonleaf (implies (smtp-cst-matchp cst "standardized-tag") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dcontent-nonleaf (implies (smtp-cst-matchp cst "dcontent") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-snum-nonleaf (implies (smtp-cst-matchp cst "snum") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6-addr-nonleaf (implies (smtp-cst-matchp cst "ipv6-addr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6-hex-nonleaf (implies (smtp-cst-matchp cst "ipv6-hex") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6-full-nonleaf (implies (smtp-cst-matchp cst "ipv6-full") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6-comp-nonleaf (implies (smtp-cst-matchp cst "ipv6-comp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6v4-full-nonleaf (implies (smtp-cst-matchp cst "ipv6v4-full") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ipv6v4-comp-nonleaf (implies (smtp-cst-matchp cst "ipv6v4-comp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-greeting-nonleaf (implies (smtp-cst-matchp cst "greeting") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-textstring-nonleaf (implies (smtp-cst-matchp cst "textstring") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-reply-line-nonleaf (implies (smtp-cst-matchp cst "reply-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-reply-code-nonleaf (implies (smtp-cst-matchp cst "reply-code") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-return-path-line-nonleaf (implies (smtp-cst-matchp cst "return-path-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-time-stamp-line-nonleaf (implies (smtp-cst-matchp cst "time-stamp-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-stamp-nonleaf (implies (smtp-cst-matchp cst "stamp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-from-domain-nonleaf (implies (smtp-cst-matchp cst "from-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-by-domain-nonleaf (implies (smtp-cst-matchp cst "by-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-extended-domain-nonleaf (implies (smtp-cst-matchp cst "extended-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-tcp-info-nonleaf (implies (smtp-cst-matchp cst "tcp-info") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-opt-info-nonleaf (implies (smtp-cst-matchp cst "opt-info") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-via-nonleaf (implies (smtp-cst-matchp cst "via") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-with-nonleaf (implies (smtp-cst-matchp cst "with") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-id-nonleaf (implies (smtp-cst-matchp cst "id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-for-nonleaf (implies (smtp-cst-matchp cst "for") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-additional-registered-clauses-nonleaf (implies (smtp-cst-matchp cst "additional-registered-clauses") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-link-nonleaf (implies (smtp-cst-matchp cst "link") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-addtl-link-nonleaf (implies (smtp-cst-matchp cst "addtl-link") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-protocol-nonleaf (implies (smtp-cst-matchp cst "protocol") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-attdl-protocol-nonleaf (implies (smtp-cst-matchp cst "attdl-protocol") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-atext-nonleaf (implies (smtp-cst-matchp cst "atext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-cfws-nonleaf (implies (smtp-cst-matchp cst "cfws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-comment-nonleaf (implies (smtp-cst-matchp cst "comment") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ccontent-nonleaf (implies (smtp-cst-matchp cst "ccontent") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ctext-nonleaf (implies (smtp-cst-matchp cst "ctext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-date-time-nonleaf (implies (smtp-cst-matchp cst "date-time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-date-nonleaf (implies (smtp-cst-matchp cst "date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-day-nonleaf (implies (smtp-cst-matchp cst "day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-day-of-week-nonleaf (implies (smtp-cst-matchp cst "day-of-week") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-day-name-nonleaf (implies (smtp-cst-matchp cst "day-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-fws-nonleaf (implies (smtp-cst-matchp cst "fws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-month-nonleaf (implies (smtp-cst-matchp cst "month") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-msg-id-nonleaf (implies (smtp-cst-matchp cst "msg-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-id-left-nonleaf (implies (smtp-cst-matchp cst "id-left") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dot-atom-text-nonleaf (implies (smtp-cst-matchp cst "dot-atom-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-id-right-nonleaf (implies (smtp-cst-matchp cst "id-right") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-no-fold-literal-nonleaf (implies (smtp-cst-matchp cst "no-fold-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dtext-nonleaf (implies (smtp-cst-matchp cst "dtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-ctext-nonleaf (implies (smtp-cst-matchp cst "obs-ctext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-day-nonleaf (implies (smtp-cst-matchp cst "obs-day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-day-of-week-nonleaf (implies (smtp-cst-matchp cst "obs-day-of-week") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-dtext-nonleaf (implies (smtp-cst-matchp cst "obs-dtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-fws-nonleaf (implies (smtp-cst-matchp cst "obs-fws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-id-left-nonleaf (implies (smtp-cst-matchp cst "obs-id-left") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-imf-local-part-nonleaf (implies (smtp-cst-matchp cst "imf-local-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dot-atom-nonleaf (implies (smtp-cst-matchp cst "dot-atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-imf-quoted-string-nonleaf (implies (smtp-cst-matchp cst "imf-quoted-string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-id-right-nonleaf (implies (smtp-cst-matchp cst "obs-id-right") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-imf-domain-nonleaf (implies (smtp-cst-matchp cst "imf-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-domain-literal-nonleaf (implies (smtp-cst-matchp cst "domain-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-domain-nonleaf (implies (smtp-cst-matchp cst "obs-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-imf-atom-nonleaf (implies (smtp-cst-matchp cst "imf-atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-local-part-nonleaf (implies (smtp-cst-matchp cst "obs-local-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-nonleaf (implies (smtp-cst-matchp cst "obs-no-ws-ctl") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-qcontent-nonleaf (implies (smtp-cst-matchp cst "qcontent") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-qtext-nonleaf (implies (smtp-cst-matchp cst "qtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-qtext-nonleaf (implies (smtp-cst-matchp cst "obs-qtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-quoted-pair-nonleaf (implies (smtp-cst-matchp cst "quoted-pair") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-qp-nonleaf (implies (smtp-cst-matchp cst "obs-qp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-time-nonleaf (implies (smtp-cst-matchp cst "time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-time-of-day-nonleaf (implies (smtp-cst-matchp cst "time-of-day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-hour-nonleaf (implies (smtp-cst-matchp cst "hour") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-minute-nonleaf (implies (smtp-cst-matchp cst "minute") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-hour-nonleaf (implies (smtp-cst-matchp cst "obs-hour") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-minute-nonleaf (implies (smtp-cst-matchp cst "obs-minute") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-second-nonleaf (implies (smtp-cst-matchp cst "second") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-second-nonleaf (implies (smtp-cst-matchp cst "obs-second") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-word-nonleaf (implies (smtp-cst-matchp cst "word") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-year-nonleaf (implies (smtp-cst-matchp cst "year") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-year-nonleaf (implies (smtp-cst-matchp cst "obs-year") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-zone-nonleaf (implies (smtp-cst-matchp cst "zone") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-obs-zone-nonleaf (implies (smtp-cst-matchp cst "obs-zone") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-alpha-nonleaf (implies (smtp-cst-matchp cst "alpha") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-cr-nonleaf (implies (smtp-cst-matchp cst "cr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-crlf-nonleaf (implies (smtp-cst-matchp cst "crlf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-digit-nonleaf (implies (smtp-cst-matchp cst "digit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-dquote-nonleaf (implies (smtp-cst-matchp cst "dquote") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-hexdig-nonleaf (implies (smtp-cst-matchp cst "hexdig") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-lf-nonleaf (implies (smtp-cst-matchp cst "lf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-sp-nonleaf (implies (smtp-cst-matchp cst "sp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-vchar-nonleaf (implies (smtp-cst-matchp cst "vchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-wsp-nonleaf (implies (smtp-cst-matchp cst "wsp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-htab-nonleaf (implies (smtp-cst-matchp cst "htab") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm smtp-cst-ehlo-rulename (implies (smtp-cst-matchp cst "ehlo") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo"))))
Theorem:
(defthm smtp-cst-helo-rulename (implies (smtp-cst-matchp cst "helo") (equal (tree-nonleaf->rulename? cst) (rulename "helo"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-rulename (implies (smtp-cst-matchp cst "ehlo-ok-rsp") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo-ok-rsp"))))
Theorem:
(defthm smtp-cst-ehlo-greet-rulename (implies (smtp-cst-matchp cst "ehlo-greet") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo-greet"))))
Theorem:
(defthm smtp-cst-ehlo-line-rulename (implies (smtp-cst-matchp cst "ehlo-line") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo-line"))))
Theorem:
(defthm smtp-cst-ehlo-keyword-rulename (implies (smtp-cst-matchp cst "ehlo-keyword") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo-keyword"))))
Theorem:
(defthm smtp-cst-ehlo-param-rulename (implies (smtp-cst-matchp cst "ehlo-param") (equal (tree-nonleaf->rulename? cst) (rulename "ehlo-param"))))
Theorem:
(defthm smtp-cst-mail-rulename (implies (smtp-cst-matchp cst "mail") (equal (tree-nonleaf->rulename? cst) (rulename "mail"))))
Theorem:
(defthm smtp-cst-rcpt-rulename (implies (smtp-cst-matchp cst "rcpt") (equal (tree-nonleaf->rulename? cst) (rulename "rcpt"))))
Theorem:
(defthm smtp-cst-data-rulename (implies (smtp-cst-matchp cst "data") (equal (tree-nonleaf->rulename? cst) (rulename "data"))))
Theorem:
(defthm smtp-cst-rset-rulename (implies (smtp-cst-matchp cst "rset") (equal (tree-nonleaf->rulename? cst) (rulename "rset"))))
Theorem:
(defthm smtp-cst-vrfy-rulename (implies (smtp-cst-matchp cst "vrfy") (equal (tree-nonleaf->rulename? cst) (rulename "vrfy"))))
Theorem:
(defthm smtp-cst-expn-rulename (implies (smtp-cst-matchp cst "expn") (equal (tree-nonleaf->rulename? cst) (rulename "expn"))))
Theorem:
(defthm smtp-cst-help-rulename (implies (smtp-cst-matchp cst "help") (equal (tree-nonleaf->rulename? cst) (rulename "help"))))
Theorem:
(defthm smtp-cst-noop-rulename (implies (smtp-cst-matchp cst "noop") (equal (tree-nonleaf->rulename? cst) (rulename "noop"))))
Theorem:
(defthm smtp-cst-quit-rulename (implies (smtp-cst-matchp cst "quit") (equal (tree-nonleaf->rulename? cst) (rulename "quit"))))
Theorem:
(defthm smtp-cst-reverse-path-rulename (implies (smtp-cst-matchp cst "reverse-path") (equal (tree-nonleaf->rulename? cst) (rulename "reverse-path"))))
Theorem:
(defthm smtp-cst-forward-path-rulename (implies (smtp-cst-matchp cst "forward-path") (equal (tree-nonleaf->rulename? cst) (rulename "forward-path"))))
Theorem:
(defthm smtp-cst-path-rulename (implies (smtp-cst-matchp cst "path") (equal (tree-nonleaf->rulename? cst) (rulename "path"))))
Theorem:
(defthm smtp-cst-a-d-l-rulename (implies (smtp-cst-matchp cst "a-d-l") (equal (tree-nonleaf->rulename? cst) (rulename "a-d-l"))))
Theorem:
(defthm smtp-cst-at-domain-rulename (implies (smtp-cst-matchp cst "at-domain") (equal (tree-nonleaf->rulename? cst) (rulename "at-domain"))))
Theorem:
(defthm smtp-cst-mail-parameters-rulename (implies (smtp-cst-matchp cst "mail-parameters") (equal (tree-nonleaf->rulename? cst) (rulename "mail-parameters"))))
Theorem:
(defthm smtp-cst-rcpt-parameters-rulename (implies (smtp-cst-matchp cst "rcpt-parameters") (equal (tree-nonleaf->rulename? cst) (rulename "rcpt-parameters"))))
Theorem:
(defthm smtp-cst-esmtp-param-rulename (implies (smtp-cst-matchp cst "esmtp-param") (equal (tree-nonleaf->rulename? cst) (rulename "esmtp-param"))))
Theorem:
(defthm smtp-cst-esmtp-keyword-rulename (implies (smtp-cst-matchp cst "esmtp-keyword") (equal (tree-nonleaf->rulename? cst) (rulename "esmtp-keyword"))))
Theorem:
(defthm smtp-cst-esmtp-value-rulename (implies (smtp-cst-matchp cst "esmtp-value") (equal (tree-nonleaf->rulename? cst) (rulename "esmtp-value"))))
Theorem:
(defthm smtp-cst-keyword-rulename (implies (smtp-cst-matchp cst "keyword") (equal (tree-nonleaf->rulename? cst) (rulename "keyword"))))
Theorem:
(defthm smtp-cst-argument-rulename (implies (smtp-cst-matchp cst "argument") (equal (tree-nonleaf->rulename? cst) (rulename "argument"))))
Theorem:
(defthm smtp-cst-domain-rulename (implies (smtp-cst-matchp cst "domain") (equal (tree-nonleaf->rulename? cst) (rulename "domain"))))
Theorem:
(defthm smtp-cst-sub-domain-rulename (implies (smtp-cst-matchp cst "sub-domain") (equal (tree-nonleaf->rulename? cst) (rulename "sub-domain"))))
Theorem:
(defthm smtp-cst-let-dig-rulename (implies (smtp-cst-matchp cst "let-dig") (equal (tree-nonleaf->rulename? cst) (rulename "let-dig"))))
Theorem:
(defthm smtp-cst-ldh-str-rulename (implies (smtp-cst-matchp cst "ldh-str") (equal (tree-nonleaf->rulename? cst) (rulename "ldh-str"))))
Theorem:
(defthm smtp-cst-address-literal-rulename (implies (smtp-cst-matchp cst "address-literal") (equal (tree-nonleaf->rulename? cst) (rulename "address-literal"))))
Theorem:
(defthm smtp-cst-mailbox-rulename (implies (smtp-cst-matchp cst "mailbox") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox"))))
Theorem:
(defthm smtp-cst-local-part-rulename (implies (smtp-cst-matchp cst "local-part") (equal (tree-nonleaf->rulename? cst) (rulename "local-part"))))
Theorem:
(defthm smtp-cst-dot-string-rulename (implies (smtp-cst-matchp cst "dot-string") (equal (tree-nonleaf->rulename? cst) (rulename "dot-string"))))
Theorem:
(defthm smtp-cst-atom-rulename (implies (smtp-cst-matchp cst "atom") (equal (tree-nonleaf->rulename? cst) (rulename "atom"))))
Theorem:
(defthm smtp-cst-quoted-string-rulename (implies (smtp-cst-matchp cst "quoted-string") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-string"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-rulename (implies (smtp-cst-matchp cst "qcontentsmtp") (equal (tree-nonleaf->rulename? cst) (rulename "qcontentsmtp"))))
Theorem:
(defthm smtp-cst-quoted-pairsmtp-rulename (implies (smtp-cst-matchp cst "quoted-pairsmtp") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-pairsmtp"))))
Theorem:
(defthm smtp-cst-qtextsmtp-rulename (implies (smtp-cst-matchp cst "qtextsmtp") (equal (tree-nonleaf->rulename? cst) (rulename "qtextsmtp"))))
Theorem:
(defthm smtp-cst-string-rulename (implies (smtp-cst-matchp cst "string") (equal (tree-nonleaf->rulename? cst) (rulename "string"))))
Theorem:
(defthm smtp-cst-ipv4-address-literal-rulename (implies (smtp-cst-matchp cst "ipv4-address-literal") (equal (tree-nonleaf->rulename? cst) (rulename "ipv4-address-literal"))))
Theorem:
(defthm smtp-cst-ipv6-address-literal-rulename (implies (smtp-cst-matchp cst "ipv6-address-literal") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6-address-literal"))))
Theorem:
(defthm smtp-cst-general-address-literal-rulename (implies (smtp-cst-matchp cst "general-address-literal") (equal (tree-nonleaf->rulename? cst) (rulename "general-address-literal"))))
Theorem:
(defthm smtp-cst-standardized-tag-rulename (implies (smtp-cst-matchp cst "standardized-tag") (equal (tree-nonleaf->rulename? cst) (rulename "standardized-tag"))))
Theorem:
(defthm smtp-cst-dcontent-rulename (implies (smtp-cst-matchp cst "dcontent") (equal (tree-nonleaf->rulename? cst) (rulename "dcontent"))))
Theorem:
(defthm smtp-cst-snum-rulename (implies (smtp-cst-matchp cst "snum") (equal (tree-nonleaf->rulename? cst) (rulename "snum"))))
Theorem:
(defthm smtp-cst-ipv6-addr-rulename (implies (smtp-cst-matchp cst "ipv6-addr") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6-addr"))))
Theorem:
(defthm smtp-cst-ipv6-hex-rulename (implies (smtp-cst-matchp cst "ipv6-hex") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6-hex"))))
Theorem:
(defthm smtp-cst-ipv6-full-rulename (implies (smtp-cst-matchp cst "ipv6-full") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6-full"))))
Theorem:
(defthm smtp-cst-ipv6-comp-rulename (implies (smtp-cst-matchp cst "ipv6-comp") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6-comp"))))
Theorem:
(defthm smtp-cst-ipv6v4-full-rulename (implies (smtp-cst-matchp cst "ipv6v4-full") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6v4-full"))))
Theorem:
(defthm smtp-cst-ipv6v4-comp-rulename (implies (smtp-cst-matchp cst "ipv6v4-comp") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6v4-comp"))))
Theorem:
(defthm smtp-cst-greeting-rulename (implies (smtp-cst-matchp cst "greeting") (equal (tree-nonleaf->rulename? cst) (rulename "greeting"))))
Theorem:
(defthm smtp-cst-textstring-rulename (implies (smtp-cst-matchp cst "textstring") (equal (tree-nonleaf->rulename? cst) (rulename "textstring"))))
Theorem:
(defthm smtp-cst-reply-line-rulename (implies (smtp-cst-matchp cst "reply-line") (equal (tree-nonleaf->rulename? cst) (rulename "reply-line"))))
Theorem:
(defthm smtp-cst-reply-code-rulename (implies (smtp-cst-matchp cst "reply-code") (equal (tree-nonleaf->rulename? cst) (rulename "reply-code"))))
Theorem:
(defthm smtp-cst-return-path-line-rulename (implies (smtp-cst-matchp cst "return-path-line") (equal (tree-nonleaf->rulename? cst) (rulename "return-path-line"))))
Theorem:
(defthm smtp-cst-time-stamp-line-rulename (implies (smtp-cst-matchp cst "time-stamp-line") (equal (tree-nonleaf->rulename? cst) (rulename "time-stamp-line"))))
Theorem:
(defthm smtp-cst-stamp-rulename (implies (smtp-cst-matchp cst "stamp") (equal (tree-nonleaf->rulename? cst) (rulename "stamp"))))
Theorem:
(defthm smtp-cst-from-domain-rulename (implies (smtp-cst-matchp cst "from-domain") (equal (tree-nonleaf->rulename? cst) (rulename "from-domain"))))
Theorem:
(defthm smtp-cst-by-domain-rulename (implies (smtp-cst-matchp cst "by-domain") (equal (tree-nonleaf->rulename? cst) (rulename "by-domain"))))
Theorem:
(defthm smtp-cst-extended-domain-rulename (implies (smtp-cst-matchp cst "extended-domain") (equal (tree-nonleaf->rulename? cst) (rulename "extended-domain"))))
Theorem:
(defthm smtp-cst-tcp-info-rulename (implies (smtp-cst-matchp cst "tcp-info") (equal (tree-nonleaf->rulename? cst) (rulename "tcp-info"))))
Theorem:
(defthm smtp-cst-opt-info-rulename (implies (smtp-cst-matchp cst "opt-info") (equal (tree-nonleaf->rulename? cst) (rulename "opt-info"))))
Theorem:
(defthm smtp-cst-via-rulename (implies (smtp-cst-matchp cst "via") (equal (tree-nonleaf->rulename? cst) (rulename "via"))))
Theorem:
(defthm smtp-cst-with-rulename (implies (smtp-cst-matchp cst "with") (equal (tree-nonleaf->rulename? cst) (rulename "with"))))
Theorem:
(defthm smtp-cst-id-rulename (implies (smtp-cst-matchp cst "id") (equal (tree-nonleaf->rulename? cst) (rulename "id"))))
Theorem:
(defthm smtp-cst-for-rulename (implies (smtp-cst-matchp cst "for") (equal (tree-nonleaf->rulename? cst) (rulename "for"))))
Theorem:
(defthm smtp-cst-additional-registered-clauses-rulename (implies (smtp-cst-matchp cst "additional-registered-clauses") (equal (tree-nonleaf->rulename? cst) (rulename "additional-registered-clauses"))))
Theorem:
(defthm smtp-cst-link-rulename (implies (smtp-cst-matchp cst "link") (equal (tree-nonleaf->rulename? cst) (rulename "link"))))
Theorem:
(defthm smtp-cst-addtl-link-rulename (implies (smtp-cst-matchp cst "addtl-link") (equal (tree-nonleaf->rulename? cst) (rulename "addtl-link"))))
Theorem:
(defthm smtp-cst-protocol-rulename (implies (smtp-cst-matchp cst "protocol") (equal (tree-nonleaf->rulename? cst) (rulename "protocol"))))
Theorem:
(defthm smtp-cst-attdl-protocol-rulename (implies (smtp-cst-matchp cst "attdl-protocol") (equal (tree-nonleaf->rulename? cst) (rulename "attdl-protocol"))))
Theorem:
(defthm smtp-cst-atext-rulename (implies (smtp-cst-matchp cst "atext") (equal (tree-nonleaf->rulename? cst) (rulename "atext"))))
Theorem:
(defthm smtp-cst-cfws-rulename (implies (smtp-cst-matchp cst "cfws") (equal (tree-nonleaf->rulename? cst) (rulename "cfws"))))
Theorem:
(defthm smtp-cst-comment-rulename (implies (smtp-cst-matchp cst "comment") (equal (tree-nonleaf->rulename? cst) (rulename "comment"))))
Theorem:
(defthm smtp-cst-ccontent-rulename (implies (smtp-cst-matchp cst "ccontent") (equal (tree-nonleaf->rulename? cst) (rulename "ccontent"))))
Theorem:
(defthm smtp-cst-ctext-rulename (implies (smtp-cst-matchp cst "ctext") (equal (tree-nonleaf->rulename? cst) (rulename "ctext"))))
Theorem:
(defthm smtp-cst-date-time-rulename (implies (smtp-cst-matchp cst "date-time") (equal (tree-nonleaf->rulename? cst) (rulename "date-time"))))
Theorem:
(defthm smtp-cst-date-rulename (implies (smtp-cst-matchp cst "date") (equal (tree-nonleaf->rulename? cst) (rulename "date"))))
Theorem:
(defthm smtp-cst-day-rulename (implies (smtp-cst-matchp cst "day") (equal (tree-nonleaf->rulename? cst) (rulename "day"))))
Theorem:
(defthm smtp-cst-day-of-week-rulename (implies (smtp-cst-matchp cst "day-of-week") (equal (tree-nonleaf->rulename? cst) (rulename "day-of-week"))))
Theorem:
(defthm smtp-cst-day-name-rulename (implies (smtp-cst-matchp cst "day-name") (equal (tree-nonleaf->rulename? cst) (rulename "day-name"))))
Theorem:
(defthm smtp-cst-fws-rulename (implies (smtp-cst-matchp cst "fws") (equal (tree-nonleaf->rulename? cst) (rulename "fws"))))
Theorem:
(defthm smtp-cst-month-rulename (implies (smtp-cst-matchp cst "month") (equal (tree-nonleaf->rulename? cst) (rulename "month"))))
Theorem:
(defthm smtp-cst-msg-id-rulename (implies (smtp-cst-matchp cst "msg-id") (equal (tree-nonleaf->rulename? cst) (rulename "msg-id"))))
Theorem:
(defthm smtp-cst-id-left-rulename (implies (smtp-cst-matchp cst "id-left") (equal (tree-nonleaf->rulename? cst) (rulename "id-left"))))
Theorem:
(defthm smtp-cst-dot-atom-text-rulename (implies (smtp-cst-matchp cst "dot-atom-text") (equal (tree-nonleaf->rulename? cst) (rulename "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-right-rulename (implies (smtp-cst-matchp cst "id-right") (equal (tree-nonleaf->rulename? cst) (rulename "id-right"))))
Theorem:
(defthm smtp-cst-no-fold-literal-rulename (implies (smtp-cst-matchp cst "no-fold-literal") (equal (tree-nonleaf->rulename? cst) (rulename "no-fold-literal"))))
Theorem:
(defthm smtp-cst-dtext-rulename (implies (smtp-cst-matchp cst "dtext") (equal (tree-nonleaf->rulename? cst) (rulename "dtext"))))
Theorem:
(defthm smtp-cst-obs-ctext-rulename (implies (smtp-cst-matchp cst "obs-ctext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-ctext"))))
Theorem:
(defthm smtp-cst-obs-day-rulename (implies (smtp-cst-matchp cst "obs-day") (equal (tree-nonleaf->rulename? cst) (rulename "obs-day"))))
Theorem:
(defthm smtp-cst-obs-day-of-week-rulename (implies (smtp-cst-matchp cst "obs-day-of-week") (equal (tree-nonleaf->rulename? cst) (rulename "obs-day-of-week"))))
Theorem:
(defthm smtp-cst-obs-dtext-rulename (implies (smtp-cst-matchp cst "obs-dtext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-dtext"))))
Theorem:
(defthm smtp-cst-obs-fws-rulename (implies (smtp-cst-matchp cst "obs-fws") (equal (tree-nonleaf->rulename? cst) (rulename "obs-fws"))))
Theorem:
(defthm smtp-cst-obs-id-left-rulename (implies (smtp-cst-matchp cst "obs-id-left") (equal (tree-nonleaf->rulename? cst) (rulename "obs-id-left"))))
Theorem:
(defthm smtp-cst-imf-local-part-rulename (implies (smtp-cst-matchp cst "imf-local-part") (equal (tree-nonleaf->rulename? cst) (rulename "imf-local-part"))))
Theorem:
(defthm smtp-cst-dot-atom-rulename (implies (smtp-cst-matchp cst "dot-atom") (equal (tree-nonleaf->rulename? cst) (rulename "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-quoted-string-rulename (implies (smtp-cst-matchp cst "imf-quoted-string") (equal (tree-nonleaf->rulename? cst) (rulename "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-obs-id-right-rulename (implies (smtp-cst-matchp cst "obs-id-right") (equal (tree-nonleaf->rulename? cst) (rulename "obs-id-right"))))
Theorem:
(defthm smtp-cst-imf-domain-rulename (implies (smtp-cst-matchp cst "imf-domain") (equal (tree-nonleaf->rulename? cst) (rulename "imf-domain"))))
Theorem:
(defthm smtp-cst-domain-literal-rulename (implies (smtp-cst-matchp cst "domain-literal") (equal (tree-nonleaf->rulename? cst) (rulename "domain-literal"))))
Theorem:
(defthm smtp-cst-obs-domain-rulename (implies (smtp-cst-matchp cst "obs-domain") (equal (tree-nonleaf->rulename? cst) (rulename "obs-domain"))))
Theorem:
(defthm smtp-cst-imf-atom-rulename (implies (smtp-cst-matchp cst "imf-atom") (equal (tree-nonleaf->rulename? cst) (rulename "imf-atom"))))
Theorem:
(defthm smtp-cst-obs-local-part-rulename (implies (smtp-cst-matchp cst "obs-local-part") (equal (tree-nonleaf->rulename? cst) (rulename "obs-local-part"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-rulename (implies (smtp-cst-matchp cst "obs-no-ws-ctl") (equal (tree-nonleaf->rulename? cst) (rulename "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-qcontent-rulename (implies (smtp-cst-matchp cst "qcontent") (equal (tree-nonleaf->rulename? cst) (rulename "qcontent"))))
Theorem:
(defthm smtp-cst-qtext-rulename (implies (smtp-cst-matchp cst "qtext") (equal (tree-nonleaf->rulename? cst) (rulename "qtext"))))
Theorem:
(defthm smtp-cst-obs-qtext-rulename (implies (smtp-cst-matchp cst "obs-qtext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-qtext"))))
Theorem:
(defthm smtp-cst-quoted-pair-rulename (implies (smtp-cst-matchp cst "quoted-pair") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-pair"))))
Theorem:
(defthm smtp-cst-obs-qp-rulename (implies (smtp-cst-matchp cst "obs-qp") (equal (tree-nonleaf->rulename? cst) (rulename "obs-qp"))))
Theorem:
(defthm smtp-cst-time-rulename (implies (smtp-cst-matchp cst "time") (equal (tree-nonleaf->rulename? cst) (rulename "time"))))
Theorem:
(defthm smtp-cst-time-of-day-rulename (implies (smtp-cst-matchp cst "time-of-day") (equal (tree-nonleaf->rulename? cst) (rulename "time-of-day"))))
Theorem:
(defthm smtp-cst-hour-rulename (implies (smtp-cst-matchp cst "hour") (equal (tree-nonleaf->rulename? cst) (rulename "hour"))))
Theorem:
(defthm smtp-cst-minute-rulename (implies (smtp-cst-matchp cst "minute") (equal (tree-nonleaf->rulename? cst) (rulename "minute"))))
Theorem:
(defthm smtp-cst-obs-hour-rulename (implies (smtp-cst-matchp cst "obs-hour") (equal (tree-nonleaf->rulename? cst) (rulename "obs-hour"))))
Theorem:
(defthm smtp-cst-obs-minute-rulename (implies (smtp-cst-matchp cst "obs-minute") (equal (tree-nonleaf->rulename? cst) (rulename "obs-minute"))))
Theorem:
(defthm smtp-cst-second-rulename (implies (smtp-cst-matchp cst "second") (equal (tree-nonleaf->rulename? cst) (rulename "second"))))
Theorem:
(defthm smtp-cst-obs-second-rulename (implies (smtp-cst-matchp cst "obs-second") (equal (tree-nonleaf->rulename? cst) (rulename "obs-second"))))
Theorem:
(defthm smtp-cst-word-rulename (implies (smtp-cst-matchp cst "word") (equal (tree-nonleaf->rulename? cst) (rulename "word"))))
Theorem:
(defthm smtp-cst-year-rulename (implies (smtp-cst-matchp cst "year") (equal (tree-nonleaf->rulename? cst) (rulename "year"))))
Theorem:
(defthm smtp-cst-obs-year-rulename (implies (smtp-cst-matchp cst "obs-year") (equal (tree-nonleaf->rulename? cst) (rulename "obs-year"))))
Theorem:
(defthm smtp-cst-zone-rulename (implies (smtp-cst-matchp cst "zone") (equal (tree-nonleaf->rulename? cst) (rulename "zone"))))
Theorem:
(defthm smtp-cst-obs-zone-rulename (implies (smtp-cst-matchp cst "obs-zone") (equal (tree-nonleaf->rulename? cst) (rulename "obs-zone"))))
Theorem:
(defthm smtp-cst-alpha-rulename (implies (smtp-cst-matchp cst "alpha") (equal (tree-nonleaf->rulename? cst) (rulename "alpha"))))
Theorem:
(defthm smtp-cst-cr-rulename (implies (smtp-cst-matchp cst "cr") (equal (tree-nonleaf->rulename? cst) (rulename "cr"))))
Theorem:
(defthm smtp-cst-crlf-rulename (implies (smtp-cst-matchp cst "crlf") (equal (tree-nonleaf->rulename? cst) (rulename "crlf"))))
Theorem:
(defthm smtp-cst-digit-rulename (implies (smtp-cst-matchp cst "digit") (equal (tree-nonleaf->rulename? cst) (rulename "digit"))))
Theorem:
(defthm smtp-cst-dquote-rulename (implies (smtp-cst-matchp cst "dquote") (equal (tree-nonleaf->rulename? cst) (rulename "dquote"))))
Theorem:
(defthm smtp-cst-hexdig-rulename (implies (smtp-cst-matchp cst "hexdig") (equal (tree-nonleaf->rulename? cst) (rulename "hexdig"))))
Theorem:
(defthm smtp-cst-lf-rulename (implies (smtp-cst-matchp cst "lf") (equal (tree-nonleaf->rulename? cst) (rulename "lf"))))
Theorem:
(defthm smtp-cst-sp-rulename (implies (smtp-cst-matchp cst "sp") (equal (tree-nonleaf->rulename? cst) (rulename "sp"))))
Theorem:
(defthm smtp-cst-vchar-rulename (implies (smtp-cst-matchp cst "vchar") (equal (tree-nonleaf->rulename? cst) (rulename "vchar"))))
Theorem:
(defthm smtp-cst-wsp-rulename (implies (smtp-cst-matchp cst "wsp") (equal (tree-nonleaf->rulename? cst) (rulename "wsp"))))
Theorem:
(defthm smtp-cst-htab-rulename (implies (smtp-cst-matchp cst "htab") (equal (tree-nonleaf->rulename? cst) (rulename "htab"))))
Theorem:
(defthm smtp-cst-ehlo-branches-match-alt (implies (smtp-cst-matchp cst "ehlo") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"EHLO\" sp ( domain / address-literal ) crlf")))
Theorem:
(defthm smtp-cst-helo-branches-match-alt (implies (smtp-cst-matchp cst "helo") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"HELO\" sp domain crlf")))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-branches-match-alt (implies (smtp-cst-matchp cst "ehlo-ok-rsp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"250\" sp domain [ sp ehlo-greet ] crlf ) / ( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )")))
Theorem:
(defthm smtp-cst-ehlo-greet-branches-match-alt (implies (smtp-cst-matchp cst "ehlo-greet") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( %d0-9 / %d11-12 / %d14-127 )")))
Theorem:
(defthm smtp-cst-ehlo-line-branches-match-alt (implies (smtp-cst-matchp cst "ehlo-line") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ehlo-keyword *( sp ehlo-param )")))
Theorem:
(defthm smtp-cst-ehlo-keyword-branches-match-alt (implies (smtp-cst-matchp cst "ehlo-keyword") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( alpha / digit ) *( alpha / digit / \"-\" )")))
Theorem:
(defthm smtp-cst-ehlo-param-branches-match-alt (implies (smtp-cst-matchp cst "ehlo-param") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( %d33-126 )")))
Theorem:
(defthm smtp-cst-mail-branches-match-alt (implies (smtp-cst-matchp cst "mail") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf")))
Theorem:
(defthm smtp-cst-rcpt-branches-match-alt (implies (smtp-cst-matchp cst "rcpt") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf")))
Theorem:
(defthm smtp-cst-data-branches-match-alt (implies (smtp-cst-matchp cst "data") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"DATA\" crlf")))
Theorem:
(defthm smtp-cst-rset-branches-match-alt (implies (smtp-cst-matchp cst "rset") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"RSET\" crlf")))
Theorem:
(defthm smtp-cst-vrfy-branches-match-alt (implies (smtp-cst-matchp cst "vrfy") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"VRFY\" sp string crlf")))
Theorem:
(defthm smtp-cst-expn-branches-match-alt (implies (smtp-cst-matchp cst "expn") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"EXPN\" sp string crlf")))
Theorem:
(defthm smtp-cst-help-branches-match-alt (implies (smtp-cst-matchp cst "help") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"HELP\" [ sp string ] crlf")))
Theorem:
(defthm smtp-cst-noop-branches-match-alt (implies (smtp-cst-matchp cst "noop") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"NOOP\" [ sp string ] crlf")))
Theorem:
(defthm smtp-cst-quit-branches-match-alt (implies (smtp-cst-matchp cst "quit") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"QUIT\" crlf")))
Theorem:
(defthm smtp-cst-reverse-path-branches-match-alt (implies (smtp-cst-matchp cst "reverse-path") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "path / \"<>\"")))
Theorem:
(defthm smtp-cst-forward-path-branches-match-alt (implies (smtp-cst-matchp cst "forward-path") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "path")))
Theorem:
(defthm smtp-cst-path-branches-match-alt (implies (smtp-cst-matchp cst "path") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"<\" [ a-d-l \":\" ] mailbox \">\"")))
Theorem:
(defthm smtp-cst-a-d-l-branches-match-alt (implies (smtp-cst-matchp cst "a-d-l") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "at-domain *( \",\" at-domain )")))
Theorem:
(defthm smtp-cst-at-domain-branches-match-alt (implies (smtp-cst-matchp cst "at-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"@\" domain")))
Theorem:
(defthm smtp-cst-mail-parameters-branches-match-alt (implies (smtp-cst-matchp cst "mail-parameters") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "esmtp-param *( sp esmtp-param )")))
Theorem:
(defthm smtp-cst-rcpt-parameters-branches-match-alt (implies (smtp-cst-matchp cst "rcpt-parameters") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "esmtp-param *( sp esmtp-param )")))
Theorem:
(defthm smtp-cst-esmtp-param-branches-match-alt (implies (smtp-cst-matchp cst "esmtp-param") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "esmtp-keyword [ \"=\" esmtp-value ]")))
Theorem:
(defthm smtp-cst-esmtp-keyword-branches-match-alt (implies (smtp-cst-matchp cst "esmtp-keyword") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( alpha / digit ) *( alpha / digit / \"-\" )")))
Theorem:
(defthm smtp-cst-esmtp-value-branches-match-alt (implies (smtp-cst-matchp cst "esmtp-value") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( %d33-60 / %d62-126 )")))
Theorem:
(defthm smtp-cst-keyword-branches-match-alt (implies (smtp-cst-matchp cst "keyword") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ldh-str")))
Theorem:
(defthm smtp-cst-argument-branches-match-alt (implies (smtp-cst-matchp cst "argument") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom")))
Theorem:
(defthm smtp-cst-domain-branches-match-alt (implies (smtp-cst-matchp cst "domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "sub-domain *( \".\" sub-domain )")))
Theorem:
(defthm smtp-cst-sub-domain-branches-match-alt (implies (smtp-cst-matchp cst "sub-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "let-dig [ ldh-str ]")))
Theorem:
(defthm smtp-cst-let-dig-branches-match-alt (implies (smtp-cst-matchp cst "let-dig") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha / digit")))
Theorem:
(defthm smtp-cst-ldh-str-branches-match-alt (implies (smtp-cst-matchp cst "ldh-str") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( alpha / digit / \"-\" ) let-dig")))
Theorem:
(defthm smtp-cst-address-literal-branches-match-alt (implies (smtp-cst-matchp cst "address-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\"")))
Theorem:
(defthm smtp-cst-mailbox-branches-match-alt (implies (smtp-cst-matchp cst "mailbox") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "local-part \"@\" ( domain / address-literal )")))
Theorem:
(defthm smtp-cst-local-part-branches-match-alt (implies (smtp-cst-matchp cst "local-part") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-string / quoted-string")))
Theorem:
(defthm smtp-cst-dot-string-branches-match-alt (implies (smtp-cst-matchp cst "dot-string") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom *( \".\" atom )")))
Theorem:
(defthm smtp-cst-atom-branches-match-alt (implies (smtp-cst-matchp cst "atom") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*atext")))
Theorem:
(defthm smtp-cst-quoted-string-branches-match-alt (implies (smtp-cst-matchp cst "quoted-string") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote *qcontentsmtp dquote")))
Theorem:
(defthm smtp-cst-qcontentsmtp-branches-match-alt (implies (smtp-cst-matchp cst "qcontentsmtp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "qtextsmtp / quoted-pairsmtp")))
Theorem:
(defthm smtp-cst-quoted-pairsmtp-branches-match-alt (implies (smtp-cst-matchp cst "quoted-pairsmtp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d92 %d32-126")))
Theorem:
(defthm smtp-cst-qtextsmtp-branches-match-alt (implies (smtp-cst-matchp cst "qtextsmtp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d32-33 / %d35-91 / %d93-126")))
Theorem:
(defthm smtp-cst-string-branches-match-alt (implies (smtp-cst-matchp cst "string") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom / quoted-string")))
Theorem:
(defthm smtp-cst-ipv4-address-literal-branches-match-alt (implies (smtp-cst-matchp cst "ipv4-address-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "snum 3( \".\" snum )")))
Theorem:
(defthm smtp-cst-ipv6-address-literal-branches-match-alt (implies (smtp-cst-matchp cst "ipv6-address-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"IPv6:\" ipv6-addr")))
Theorem:
(defthm smtp-cst-general-address-literal-branches-match-alt (implies (smtp-cst-matchp cst "general-address-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "standardized-tag \":\" 1*dcontent")))
Theorem:
(defthm smtp-cst-standardized-tag-branches-match-alt (implies (smtp-cst-matchp cst "standardized-tag") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ldh-str")))
Theorem:
(defthm smtp-cst-dcontent-branches-match-alt (implies (smtp-cst-matchp cst "dcontent") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-90 / %d94-126")))
Theorem:
(defthm smtp-cst-snum-branches-match-alt (implies (smtp-cst-matchp cst "snum") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*3digit")))
Theorem:
(defthm smtp-cst-ipv6-addr-branches-match-alt (implies (smtp-cst-matchp cst "ipv6-addr") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ipv6-full / ipv6-comp / ipv6v4-full / ipv6v4-comp")))
Theorem:
(defthm smtp-cst-ipv6-hex-branches-match-alt (implies (smtp-cst-matchp cst "ipv6-hex") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*4hexdig")))
Theorem:
(defthm smtp-cst-ipv6-full-branches-match-alt (implies (smtp-cst-matchp cst "ipv6-full") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ipv6-hex 7( \":\" ipv6-hex )")))
Theorem:
(defthm smtp-cst-ipv6-comp-branches-match-alt (implies (smtp-cst-matchp cst "ipv6-comp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]")))
Theorem:
(defthm smtp-cst-ipv6v4-full-branches-match-alt (implies (smtp-cst-matchp cst "ipv6v4-full") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal")))
Theorem:
(defthm smtp-cst-ipv6v4-comp-branches-match-alt (implies (smtp-cst-matchp cst "ipv6v4-comp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal")))
Theorem:
(defthm smtp-cst-greeting-branches-match-alt (implies (smtp-cst-matchp cst "greeting") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf ) / ( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )")))
Theorem:
(defthm smtp-cst-textstring-branches-match-alt (implies (smtp-cst-matchp cst "textstring") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( %d9 / %d32-126 )")))
Theorem:
(defthm smtp-cst-reply-line-branches-match-alt (implies (smtp-cst-matchp cst "reply-line") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf")))
Theorem:
(defthm smtp-cst-reply-code-branches-match-alt (implies (smtp-cst-matchp cst "reply-code") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x32-35 %x30-35 %x30-39")))
Theorem:
(defthm smtp-cst-return-path-line-branches-match-alt (implies (smtp-cst-matchp cst "return-path-line") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Return-Path:\" fws reverse-path crlf")))
Theorem:
(defthm smtp-cst-time-stamp-line-branches-match-alt (implies (smtp-cst-matchp cst "time-stamp-line") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Received:\" fws stamp crlf")))
Theorem:
(defthm smtp-cst-stamp-branches-match-alt (implies (smtp-cst-matchp cst "stamp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "from-domain by-domain opt-info [ cfws ] \";\" fws date-time")))
Theorem:
(defthm smtp-cst-from-domain-branches-match-alt (implies (smtp-cst-matchp cst "from-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"FROM\" fws extended-domain")))
Theorem:
(defthm smtp-cst-by-domain-branches-match-alt (implies (smtp-cst-matchp cst "by-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws \"BY\" fws extended-domain")))
Theorem:
(defthm smtp-cst-extended-domain-branches-match-alt (implies (smtp-cst-matchp cst "extended-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "domain / ( domain fws \"(\" tcp-info \")\" ) / ( address-literal fws \"(\" tcp-info \")\" )")))
Theorem:
(defthm smtp-cst-tcp-info-branches-match-alt (implies (smtp-cst-matchp cst "tcp-info") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "address-literal / ( domain fws address-literal )")))
Theorem:
(defthm smtp-cst-opt-info-branches-match-alt (implies (smtp-cst-matchp cst "opt-info") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]")))
Theorem:
(defthm smtp-cst-via-branches-match-alt (implies (smtp-cst-matchp cst "via") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws \"VIA\" fws link")))
Theorem:
(defthm smtp-cst-with-branches-match-alt (implies (smtp-cst-matchp cst "with") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws \"WITH\" fws protocol")))
Theorem:
(defthm smtp-cst-id-branches-match-alt (implies (smtp-cst-matchp cst "id") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws \"ID\" fws ( atom / msg-id )")))
Theorem:
(defthm smtp-cst-for-branches-match-alt (implies (smtp-cst-matchp cst "for") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws \"FOR\" fws ( path / mailbox )")))
Theorem:
(defthm smtp-cst-additional-registered-clauses-branches-match-alt (implies (smtp-cst-matchp cst "additional-registered-clauses") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cfws atom fws string")))
Theorem:
(defthm smtp-cst-link-branches-match-alt (implies (smtp-cst-matchp cst "link") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"TCP\" / addtl-link")))
Theorem:
(defthm smtp-cst-addtl-link-branches-match-alt (implies (smtp-cst-matchp cst "addtl-link") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom")))
Theorem:
(defthm smtp-cst-protocol-branches-match-alt (implies (smtp-cst-matchp cst "protocol") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"ESMTP\" / \"SMTP\" / attdl-protocol")))
Theorem:
(defthm smtp-cst-attdl-protocol-branches-match-alt (implies (smtp-cst-matchp cst "attdl-protocol") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom")))
Theorem:
(defthm smtp-cst-atext-branches-match-alt (implies (smtp-cst-matchp cst "atext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"")))
Theorem:
(defthm smtp-cst-cfws-branches-match-alt (implies (smtp-cst-matchp cst "cfws") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( 1*( [ fws ] comment ) [ fws ] ) / fws")))
Theorem:
(defthm smtp-cst-comment-branches-match-alt (implies (smtp-cst-matchp cst "comment") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"")))
Theorem:
(defthm smtp-cst-ccontent-branches-match-alt (implies (smtp-cst-matchp cst "ccontent") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ctext / quoted-pair / comment")))
Theorem:
(defthm smtp-cst-ctext-branches-match-alt (implies (smtp-cst-matchp cst "ctext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-39 / %d42-91 / %d93-126 / obs-ctext")))
Theorem:
(defthm smtp-cst-date-time-branches-match-alt (implies (smtp-cst-matchp cst "date-time") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ day-of-week \",\" ] date time [ cfws ]")))
Theorem:
(defthm smtp-cst-date-branches-match-alt (implies (smtp-cst-matchp cst "date") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "day month year")))
Theorem:
(defthm smtp-cst-day-branches-match-alt (implies (smtp-cst-matchp cst "day") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ fws ] 1*2digit fws ) / obs-day")))
Theorem:
(defthm smtp-cst-day-of-week-branches-match-alt (implies (smtp-cst-matchp cst "day-of-week") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ fws ] day-name ) / obs-day-of-week")))
Theorem:
(defthm smtp-cst-day-name-branches-match-alt (implies (smtp-cst-matchp cst "day-name") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"")))
Theorem:
(defthm smtp-cst-fws-branches-match-alt (implies (smtp-cst-matchp cst "fws") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ *wsp crlf ] 1*wsp ) / obs-fws")))
Theorem:
(defthm smtp-cst-month-branches-match-alt (implies (smtp-cst-matchp cst "month") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"")))
Theorem:
(defthm smtp-cst-msg-id-branches-match-alt (implies (smtp-cst-matchp cst "msg-id") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]")))
Theorem:
(defthm smtp-cst-id-left-branches-match-alt (implies (smtp-cst-matchp cst "id-left") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom-text / obs-id-left")))
Theorem:
(defthm smtp-cst-dot-atom-text-branches-match-alt (implies (smtp-cst-matchp cst "dot-atom-text") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*atext *( \".\" 1*atext )")))
Theorem:
(defthm smtp-cst-id-right-branches-match-alt (implies (smtp-cst-matchp cst "id-right") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom-text / no-fold-literal / obs-id-right")))
Theorem:
(defthm smtp-cst-no-fold-literal-branches-match-alt (implies (smtp-cst-matchp cst "no-fold-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"[\" *dtext \"]\"")))
Theorem:
(defthm smtp-cst-dtext-branches-match-alt (implies (smtp-cst-matchp cst "dtext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-90 / %d94-126 / obs-dtext")))
Theorem:
(defthm smtp-cst-obs-ctext-branches-match-alt (implies (smtp-cst-matchp cst "obs-ctext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl")))
Theorem:
(defthm smtp-cst-obs-day-branches-match-alt (implies (smtp-cst-matchp cst "obs-day") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 1*2digit [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-day-of-week-branches-match-alt (implies (smtp-cst-matchp cst "obs-day-of-week") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] day-name [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-dtext-branches-match-alt (implies (smtp-cst-matchp cst "obs-dtext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl / quoted-pair")))
Theorem:
(defthm smtp-cst-obs-fws-branches-match-alt (implies (smtp-cst-matchp cst "obs-fws") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*wsp *( crlf 1*wsp )")))
Theorem:
(defthm smtp-cst-obs-id-left-branches-match-alt (implies (smtp-cst-matchp cst "obs-id-left") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "imf-local-part")))
Theorem:
(defthm smtp-cst-imf-local-part-branches-match-alt (implies (smtp-cst-matchp cst "imf-local-part") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom / imf-quoted-string / obs-local-part")))
Theorem:
(defthm smtp-cst-dot-atom-branches-match-alt (implies (smtp-cst-matchp cst "dot-atom") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] dot-atom-text [ cfws ]")))
Theorem:
(defthm smtp-cst-imf-quoted-string-branches-match-alt (implies (smtp-cst-matchp cst "imf-quoted-string") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-id-right-branches-match-alt (implies (smtp-cst-matchp cst "obs-id-right") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "imf-domain")))
Theorem:
(defthm smtp-cst-imf-domain-branches-match-alt (implies (smtp-cst-matchp cst "imf-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom / domain-literal / obs-domain")))
Theorem:
(defthm smtp-cst-domain-literal-branches-match-alt (implies (smtp-cst-matchp cst "domain-literal") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-domain-branches-match-alt (implies (smtp-cst-matchp cst "obs-domain") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "imf-atom *( \".\" imf-atom )")))
Theorem:
(defthm smtp-cst-imf-atom-branches-match-alt (implies (smtp-cst-matchp cst "imf-atom") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 1*atext [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-local-part-branches-match-alt (implies (smtp-cst-matchp cst "obs-local-part") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "word *( \".\" word )")))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-branches-match-alt (implies (smtp-cst-matchp cst "obs-no-ws-ctl") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d1-8 / %d11 / %d12 / %d14-31 / %d127")))
Theorem:
(defthm smtp-cst-qcontent-branches-match-alt (implies (smtp-cst-matchp cst "qcontent") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "qtext / quoted-pair")))
Theorem:
(defthm smtp-cst-qtext-branches-match-alt (implies (smtp-cst-matchp cst "qtext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33 / %d35-91 / %d93-126 / obs-qtext")))
Theorem:
(defthm smtp-cst-obs-qtext-branches-match-alt (implies (smtp-cst-matchp cst "obs-qtext") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl")))
Theorem:
(defthm smtp-cst-quoted-pair-branches-match-alt (implies (smtp-cst-matchp cst "quoted-pair") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"\\\" ( vchar / wsp ) ) / obs-qp")))
Theorem:
(defthm smtp-cst-obs-qp-branches-match-alt (implies (smtp-cst-matchp cst "obs-qp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )")))
Theorem:
(defthm smtp-cst-time-branches-match-alt (implies (smtp-cst-matchp cst "time") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "time-of-day zone")))
Theorem:
(defthm smtp-cst-time-of-day-branches-match-alt (implies (smtp-cst-matchp cst "time-of-day") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "hour \":\" minute [ \":\" second ]")))
Theorem:
(defthm smtp-cst-hour-branches-match-alt (implies (smtp-cst-matchp cst "hour") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-hour")))
Theorem:
(defthm smtp-cst-minute-branches-match-alt (implies (smtp-cst-matchp cst "minute") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-minute")))
Theorem:
(defthm smtp-cst-obs-hour-branches-match-alt (implies (smtp-cst-matchp cst "obs-hour") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm smtp-cst-obs-minute-branches-match-alt (implies (smtp-cst-matchp cst "obs-minute") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm smtp-cst-second-branches-match-alt (implies (smtp-cst-matchp cst "second") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-second")))
Theorem:
(defthm smtp-cst-obs-second-branches-match-alt (implies (smtp-cst-matchp cst "obs-second") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm smtp-cst-word-branches-match-alt (implies (smtp-cst-matchp cst "word") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "imf-atom / imf-quoted-string")))
Theorem:
(defthm smtp-cst-year-branches-match-alt (implies (smtp-cst-matchp cst "year") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( fws 4*digit fws ) / obs-year")))
Theorem:
(defthm smtp-cst-obs-year-branches-match-alt (implies (smtp-cst-matchp cst "obs-year") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2*digit [ cfws ]")))
Theorem:
(defthm smtp-cst-zone-branches-match-alt (implies (smtp-cst-matchp cst "zone") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone")))
Theorem:
(defthm smtp-cst-obs-zone-branches-match-alt (implies (smtp-cst-matchp cst "obs-zone") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"UT\" / \"GMT\" / \"EST\" / \"EDT\" / \"CST\" / \"CDT\" / \"MST\" / \"MDT\" / \"PST\" / \"PDT\" / %d65-73 / %d75-90 / %d97-105 / %d107-122")))
Theorem:
(defthm smtp-cst-alpha-branches-match-alt (implies (smtp-cst-matchp cst "alpha") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x41-5A / %x61-7A")))
Theorem:
(defthm smtp-cst-cr-branches-match-alt (implies (smtp-cst-matchp cst "cr") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xD")))
Theorem:
(defthm smtp-cst-crlf-branches-match-alt (implies (smtp-cst-matchp cst "crlf") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cr lf")))
Theorem:
(defthm smtp-cst-digit-branches-match-alt (implies (smtp-cst-matchp cst "digit") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30-39")))
Theorem:
(defthm smtp-cst-dquote-branches-match-alt (implies (smtp-cst-matchp cst "dquote") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x22")))
Theorem:
(defthm smtp-cst-hexdig-branches-match-alt (implies (smtp-cst-matchp cst "hexdig") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"")))
Theorem:
(defthm smtp-cst-lf-branches-match-alt (implies (smtp-cst-matchp cst "lf") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xA")))
Theorem:
(defthm smtp-cst-sp-branches-match-alt (implies (smtp-cst-matchp cst "sp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20")))
Theorem:
(defthm smtp-cst-vchar-branches-match-alt (implies (smtp-cst-matchp cst "vchar") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x21-7E")))
Theorem:
(defthm smtp-cst-wsp-branches-match-alt (implies (smtp-cst-matchp cst "wsp") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "sp / htab")))
Theorem:
(defthm smtp-cst-htab-branches-match-alt (implies (smtp-cst-matchp cst "htab") (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x9")))
Theorem:
(defthm smtp-cst-ehlo-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"EHLO\" sp ( domain / address-literal ) crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"EHLO\" sp ( domain / address-literal ) crlf"))))
Theorem:
(defthm smtp-cst-helo-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"HELO\" sp domain crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"HELO\" sp domain crlf"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-concs (implies (smtp-cst-list-list-alt-matchp cstss "( \"250\" sp domain [ sp ehlo-greet ] crlf ) / ( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )") (or (smtp-cst-list-list-conc-matchp cstss "( \"250\" sp domain [ sp ehlo-greet ] crlf )") (smtp-cst-list-list-conc-matchp cstss "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))
Theorem:
(defthm smtp-cst-ehlo-greet-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*( %d0-9 / %d11-12 / %d14-127 )") (or (smtp-cst-list-list-conc-matchp cstss "1*( %d0-9 / %d11-12 / %d14-127 )"))))
Theorem:
(defthm smtp-cst-ehlo-line-concs (implies (smtp-cst-list-list-alt-matchp cstss "ehlo-keyword *( sp ehlo-param )") (or (smtp-cst-list-list-conc-matchp cstss "ehlo-keyword *( sp ehlo-param )"))))
Theorem:
(defthm smtp-cst-ehlo-keyword-concs (implies (smtp-cst-list-list-alt-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )") (or (smtp-cst-list-list-conc-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )"))))
Theorem:
(defthm smtp-cst-ehlo-param-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*( %d33-126 )") (or (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )"))))
Theorem:
(defthm smtp-cst-mail-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf"))))
Theorem:
(defthm smtp-cst-rcpt-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf"))))
Theorem:
(defthm smtp-cst-data-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"DATA\" crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"DATA\" crlf"))))
Theorem:
(defthm smtp-cst-rset-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"RSET\" crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"RSET\" crlf"))))
Theorem:
(defthm smtp-cst-vrfy-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"VRFY\" sp string crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"VRFY\" sp string crlf"))))
Theorem:
(defthm smtp-cst-expn-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"EXPN\" sp string crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"EXPN\" sp string crlf"))))
Theorem:
(defthm smtp-cst-help-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"HELP\" [ sp string ] crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"HELP\" [ sp string ] crlf"))))
Theorem:
(defthm smtp-cst-noop-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"NOOP\" [ sp string ] crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"NOOP\" [ sp string ] crlf"))))
Theorem:
(defthm smtp-cst-quit-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"QUIT\" crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"QUIT\" crlf"))))
Theorem:
(defthm smtp-cst-reverse-path-concs (implies (smtp-cst-list-list-alt-matchp cstss "path / \"<>\"") (or (smtp-cst-list-list-conc-matchp cstss "path") (smtp-cst-list-list-conc-matchp cstss "\"<>\""))))
Theorem:
(defthm smtp-cst-forward-path-concs (implies (smtp-cst-list-list-alt-matchp cstss "path") (or (smtp-cst-list-list-conc-matchp cstss "path"))))
Theorem:
(defthm smtp-cst-path-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"<\" [ a-d-l \":\" ] mailbox \">\"") (or (smtp-cst-list-list-conc-matchp cstss "\"<\" [ a-d-l \":\" ] mailbox \">\""))))
Theorem:
(defthm smtp-cst-a-d-l-concs (implies (smtp-cst-list-list-alt-matchp cstss "at-domain *( \",\" at-domain )") (or (smtp-cst-list-list-conc-matchp cstss "at-domain *( \",\" at-domain )"))))
Theorem:
(defthm smtp-cst-at-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"@\" domain") (or (smtp-cst-list-list-conc-matchp cstss "\"@\" domain"))))
Theorem:
(defthm smtp-cst-mail-parameters-concs (implies (smtp-cst-list-list-alt-matchp cstss "esmtp-param *( sp esmtp-param )") (or (smtp-cst-list-list-conc-matchp cstss "esmtp-param *( sp esmtp-param )"))))
Theorem:
(defthm smtp-cst-rcpt-parameters-concs (implies (smtp-cst-list-list-alt-matchp cstss "esmtp-param *( sp esmtp-param )") (or (smtp-cst-list-list-conc-matchp cstss "esmtp-param *( sp esmtp-param )"))))
Theorem:
(defthm smtp-cst-esmtp-param-concs (implies (smtp-cst-list-list-alt-matchp cstss "esmtp-keyword [ \"=\" esmtp-value ]") (or (smtp-cst-list-list-conc-matchp cstss "esmtp-keyword [ \"=\" esmtp-value ]"))))
Theorem:
(defthm smtp-cst-esmtp-keyword-concs (implies (smtp-cst-list-list-alt-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )") (or (smtp-cst-list-list-conc-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )"))))
Theorem:
(defthm smtp-cst-esmtp-value-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*( %d33-60 / %d62-126 )") (or (smtp-cst-list-list-conc-matchp cstss "1*( %d33-60 / %d62-126 )"))))
Theorem:
(defthm smtp-cst-keyword-concs (implies (smtp-cst-list-list-alt-matchp cstss "ldh-str") (or (smtp-cst-list-list-conc-matchp cstss "ldh-str"))))
Theorem:
(defthm smtp-cst-argument-concs (implies (smtp-cst-list-list-alt-matchp cstss "atom") (or (smtp-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm smtp-cst-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "sub-domain *( \".\" sub-domain )") (or (smtp-cst-list-list-conc-matchp cstss "sub-domain *( \".\" sub-domain )"))))
Theorem:
(defthm smtp-cst-sub-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "let-dig [ ldh-str ]") (or (smtp-cst-list-list-conc-matchp cstss "let-dig [ ldh-str ]"))))
Theorem:
(defthm smtp-cst-let-dig-concs (implies (smtp-cst-list-list-alt-matchp cstss "alpha / digit") (or (smtp-cst-list-list-conc-matchp cstss "alpha") (smtp-cst-list-list-conc-matchp cstss "digit"))))
Theorem:
(defthm smtp-cst-ldh-str-concs (implies (smtp-cst-list-list-alt-matchp cstss "*( alpha / digit / \"-\" ) let-dig") (or (smtp-cst-list-list-conc-matchp cstss "*( alpha / digit / \"-\" ) let-dig"))))
Theorem:
(defthm smtp-cst-address-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\"") (or (smtp-cst-list-list-conc-matchp cstss "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\""))))
Theorem:
(defthm smtp-cst-mailbox-concs (implies (smtp-cst-list-list-alt-matchp cstss "local-part \"@\" ( domain / address-literal )") (or (smtp-cst-list-list-conc-matchp cstss "local-part \"@\" ( domain / address-literal )"))))
Theorem:
(defthm smtp-cst-local-part-concs (implies (smtp-cst-list-list-alt-matchp cstss "dot-string / quoted-string") (or (smtp-cst-list-list-conc-matchp cstss "dot-string") (smtp-cst-list-list-conc-matchp cstss "quoted-string"))))
Theorem:
(defthm smtp-cst-dot-string-concs (implies (smtp-cst-list-list-alt-matchp cstss "atom *( \".\" atom )") (or (smtp-cst-list-list-conc-matchp cstss "atom *( \".\" atom )"))))
Theorem:
(defthm smtp-cst-atom-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*atext") (or (smtp-cst-list-list-conc-matchp cstss "1*atext"))))
Theorem:
(defthm smtp-cst-quoted-string-concs (implies (smtp-cst-list-list-alt-matchp cstss "dquote *qcontentsmtp dquote") (or (smtp-cst-list-list-conc-matchp cstss "dquote *qcontentsmtp dquote"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-concs (implies (smtp-cst-list-list-alt-matchp cstss "qtextsmtp / quoted-pairsmtp") (or (smtp-cst-list-list-conc-matchp cstss "qtextsmtp") (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp"))))
Theorem:
(defthm smtp-cst-quoted-pairsmtp-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d92 %d32-126") (or (smtp-cst-list-list-conc-matchp cstss "%d92 %d32-126"))))
Theorem:
(defthm smtp-cst-qtextsmtp-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d32-33 / %d35-91 / %d93-126") (or (smtp-cst-list-list-conc-matchp cstss "%d32-33") (smtp-cst-list-list-conc-matchp cstss "%d35-91") (smtp-cst-list-list-conc-matchp cstss "%d93-126"))))
Theorem:
(defthm smtp-cst-string-concs (implies (smtp-cst-list-list-alt-matchp cstss "atom / quoted-string") (or (smtp-cst-list-list-conc-matchp cstss "atom") (smtp-cst-list-list-conc-matchp cstss "quoted-string"))))
Theorem:
(defthm smtp-cst-ipv4-address-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "snum 3( \".\" snum )") (or (smtp-cst-list-list-conc-matchp cstss "snum 3( \".\" snum )"))))
Theorem:
(defthm smtp-cst-ipv6-address-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"IPv6:\" ipv6-addr") (or (smtp-cst-list-list-conc-matchp cstss "\"IPv6:\" ipv6-addr"))))
Theorem:
(defthm smtp-cst-general-address-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "standardized-tag \":\" 1*dcontent") (or (smtp-cst-list-list-conc-matchp cstss "standardized-tag \":\" 1*dcontent"))))
Theorem:
(defthm smtp-cst-standardized-tag-concs (implies (smtp-cst-list-list-alt-matchp cstss "ldh-str") (or (smtp-cst-list-list-conc-matchp cstss "ldh-str"))))
Theorem:
(defthm smtp-cst-dcontent-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d33-90 / %d94-126") (or (smtp-cst-list-list-conc-matchp cstss "%d33-90") (smtp-cst-list-list-conc-matchp cstss "%d94-126"))))
Theorem:
(defthm smtp-cst-snum-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*3digit") (or (smtp-cst-list-list-conc-matchp cstss "1*3digit"))))
Theorem:
(defthm smtp-cst-ipv6-addr-concs (implies (smtp-cst-list-list-alt-matchp cstss "ipv6-full / ipv6-comp / ipv6v4-full / ipv6v4-comp") (or (smtp-cst-list-list-conc-matchp cstss "ipv6-full") (smtp-cst-list-list-conc-matchp cstss "ipv6-comp") (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full") (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp"))))
Theorem:
(defthm smtp-cst-ipv6-hex-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*4hexdig") (or (smtp-cst-list-list-conc-matchp cstss "1*4hexdig"))))
Theorem:
(defthm smtp-cst-ipv6-full-concs (implies (smtp-cst-list-list-alt-matchp cstss "ipv6-hex 7( \":\" ipv6-hex )") (or (smtp-cst-list-list-conc-matchp cstss "ipv6-hex 7( \":\" ipv6-hex )"))))
Theorem:
(defthm smtp-cst-ipv6-comp-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]") (or (smtp-cst-list-list-conc-matchp cstss "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]"))))
Theorem:
(defthm smtp-cst-ipv6v4-full-concs (implies (smtp-cst-list-list-alt-matchp cstss "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal") (or (smtp-cst-list-list-conc-matchp cstss "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal"))))
Theorem:
(defthm smtp-cst-ipv6v4-comp-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal") (or (smtp-cst-list-list-conc-matchp cstss "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal"))))
Theorem:
(defthm smtp-cst-greeting-concs (implies (smtp-cst-list-list-alt-matchp cstss "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf ) / ( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )") (or (smtp-cst-list-list-conc-matchp cstss "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )") (smtp-cst-list-list-conc-matchp cstss "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))
Theorem:
(defthm smtp-cst-textstring-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*( %d9 / %d32-126 )") (or (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )"))))
Theorem:
(defthm smtp-cst-reply-line-concs (implies (smtp-cst-list-list-alt-matchp cstss "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf") (or (smtp-cst-list-list-conc-matchp cstss "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf"))))
Theorem:
(defthm smtp-cst-reply-code-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x32-35 %x30-35 %x30-39") (or (smtp-cst-list-list-conc-matchp cstss "%x32-35 %x30-35 %x30-39"))))
Theorem:
(defthm smtp-cst-return-path-line-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"Return-Path:\" fws reverse-path crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"Return-Path:\" fws reverse-path crlf"))))
Theorem:
(defthm smtp-cst-time-stamp-line-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"Received:\" fws stamp crlf") (or (smtp-cst-list-list-conc-matchp cstss "\"Received:\" fws stamp crlf"))))
Theorem:
(defthm smtp-cst-stamp-concs (implies (smtp-cst-list-list-alt-matchp cstss "from-domain by-domain opt-info [ cfws ] \";\" fws date-time") (or (smtp-cst-list-list-conc-matchp cstss "from-domain by-domain opt-info [ cfws ] \";\" fws date-time"))))
Theorem:
(defthm smtp-cst-from-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"FROM\" fws extended-domain") (or (smtp-cst-list-list-conc-matchp cstss "\"FROM\" fws extended-domain"))))
Theorem:
(defthm smtp-cst-by-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws \"BY\" fws extended-domain") (or (smtp-cst-list-list-conc-matchp cstss "cfws \"BY\" fws extended-domain"))))
Theorem:
(defthm smtp-cst-extended-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "domain / ( domain fws \"(\" tcp-info \")\" ) / ( address-literal fws \"(\" tcp-info \")\" )") (or (smtp-cst-list-list-conc-matchp cstss "domain") (smtp-cst-list-list-conc-matchp cstss "( domain fws \"(\" tcp-info \")\" )") (smtp-cst-list-list-conc-matchp cstss "( address-literal fws \"(\" tcp-info \")\" )"))))
Theorem:
(defthm smtp-cst-tcp-info-concs (implies (smtp-cst-list-list-alt-matchp cstss "address-literal / ( domain fws address-literal )") (or (smtp-cst-list-list-conc-matchp cstss "address-literal") (smtp-cst-list-list-conc-matchp cstss "( domain fws address-literal )"))))
Theorem:
(defthm smtp-cst-opt-info-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]") (or (smtp-cst-list-list-conc-matchp cstss "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]"))))
Theorem:
(defthm smtp-cst-via-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws \"VIA\" fws link") (or (smtp-cst-list-list-conc-matchp cstss "cfws \"VIA\" fws link"))))
Theorem:
(defthm smtp-cst-with-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws \"WITH\" fws protocol") (or (smtp-cst-list-list-conc-matchp cstss "cfws \"WITH\" fws protocol"))))
Theorem:
(defthm smtp-cst-id-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws \"ID\" fws ( atom / msg-id )") (or (smtp-cst-list-list-conc-matchp cstss "cfws \"ID\" fws ( atom / msg-id )"))))
Theorem:
(defthm smtp-cst-for-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws \"FOR\" fws ( path / mailbox )") (or (smtp-cst-list-list-conc-matchp cstss "cfws \"FOR\" fws ( path / mailbox )"))))
Theorem:
(defthm smtp-cst-additional-registered-clauses-concs (implies (smtp-cst-list-list-alt-matchp cstss "cfws atom fws string") (or (smtp-cst-list-list-conc-matchp cstss "cfws atom fws string"))))
Theorem:
(defthm smtp-cst-link-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"TCP\" / addtl-link") (or (smtp-cst-list-list-conc-matchp cstss "\"TCP\"") (smtp-cst-list-list-conc-matchp cstss "addtl-link"))))
Theorem:
(defthm smtp-cst-addtl-link-concs (implies (smtp-cst-list-list-alt-matchp cstss "atom") (or (smtp-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm smtp-cst-protocol-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"ESMTP\" / \"SMTP\" / attdl-protocol") (or (smtp-cst-list-list-conc-matchp cstss "\"ESMTP\"") (smtp-cst-list-list-conc-matchp cstss "\"SMTP\"") (smtp-cst-list-list-conc-matchp cstss "attdl-protocol"))))
Theorem:
(defthm smtp-cst-attdl-protocol-concs (implies (smtp-cst-list-list-alt-matchp cstss "atom") (or (smtp-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm smtp-cst-atext-concs (implies (smtp-cst-list-list-alt-matchp cstss "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"") (or (smtp-cst-list-list-conc-matchp cstss "alpha") (smtp-cst-list-list-conc-matchp cstss "digit") (smtp-cst-list-list-conc-matchp cstss "\"!\"") (smtp-cst-list-list-conc-matchp cstss "\"#\"") (smtp-cst-list-list-conc-matchp cstss "\"$\"") (smtp-cst-list-list-conc-matchp cstss "\"%\"") (smtp-cst-list-list-conc-matchp cstss "\"&\"") (smtp-cst-list-list-conc-matchp cstss "\"'\"") (smtp-cst-list-list-conc-matchp cstss "\"*\"") (smtp-cst-list-list-conc-matchp cstss "\"+\"") (smtp-cst-list-list-conc-matchp cstss "\"-\"") (smtp-cst-list-list-conc-matchp cstss "\"/\"") (smtp-cst-list-list-conc-matchp cstss "\"=\"") (smtp-cst-list-list-conc-matchp cstss "\"?\"") (smtp-cst-list-list-conc-matchp cstss "\"^\"") (smtp-cst-list-list-conc-matchp cstss "\"_\"") (smtp-cst-list-list-conc-matchp cstss "\"`\"") (smtp-cst-list-list-conc-matchp cstss "\"{\"") (smtp-cst-list-list-conc-matchp cstss "\"|\"") (smtp-cst-list-list-conc-matchp cstss "\"}\"") (smtp-cst-list-list-conc-matchp cstss "\"~\""))))
Theorem:
(defthm smtp-cst-cfws-concs (implies (smtp-cst-list-list-alt-matchp cstss "( 1*( [ fws ] comment ) [ fws ] ) / fws") (or (smtp-cst-list-list-conc-matchp cstss "( 1*( [ fws ] comment ) [ fws ] )") (smtp-cst-list-list-conc-matchp cstss "fws"))))
Theorem:
(defthm smtp-cst-comment-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"") (or (smtp-cst-list-list-conc-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\""))))
Theorem:
(defthm smtp-cst-ccontent-concs (implies (smtp-cst-list-list-alt-matchp cstss "ctext / quoted-pair / comment") (or (smtp-cst-list-list-conc-matchp cstss "ctext") (smtp-cst-list-list-conc-matchp cstss "quoted-pair") (smtp-cst-list-list-conc-matchp cstss "comment"))))
Theorem:
(defthm smtp-cst-ctext-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d33-39 / %d42-91 / %d93-126 / obs-ctext") (or (smtp-cst-list-list-conc-matchp cstss "%d33-39") (smtp-cst-list-list-conc-matchp cstss "%d42-91") (smtp-cst-list-list-conc-matchp cstss "%d93-126") (smtp-cst-list-list-conc-matchp cstss "obs-ctext"))))
Theorem:
(defthm smtp-cst-date-time-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]"))))
Theorem:
(defthm smtp-cst-date-concs (implies (smtp-cst-list-list-alt-matchp cstss "day month year") (or (smtp-cst-list-list-conc-matchp cstss "day month year"))))
Theorem:
(defthm smtp-cst-day-concs (implies (smtp-cst-list-list-alt-matchp cstss "( [ fws ] 1*2digit fws ) / obs-day") (or (smtp-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )") (smtp-cst-list-list-conc-matchp cstss "obs-day"))))
Theorem:
(defthm smtp-cst-day-of-week-concs (implies (smtp-cst-list-list-alt-matchp cstss "( [ fws ] day-name ) / obs-day-of-week") (or (smtp-cst-list-list-conc-matchp cstss "( [ fws ] day-name )") (smtp-cst-list-list-conc-matchp cstss "obs-day-of-week"))))
Theorem:
(defthm smtp-cst-day-name-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"") (or (smtp-cst-list-list-conc-matchp cstss "\"Mon\"") (smtp-cst-list-list-conc-matchp cstss "\"Tue\"") (smtp-cst-list-list-conc-matchp cstss "\"Wed\"") (smtp-cst-list-list-conc-matchp cstss "\"Thu\"") (smtp-cst-list-list-conc-matchp cstss "\"Fri\"") (smtp-cst-list-list-conc-matchp cstss "\"Sat\"") (smtp-cst-list-list-conc-matchp cstss "\"Sun\""))))
Theorem:
(defthm smtp-cst-fws-concs (implies (smtp-cst-list-list-alt-matchp cstss "( [ *wsp crlf ] 1*wsp ) / obs-fws") (or (smtp-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )") (smtp-cst-list-list-conc-matchp cstss "obs-fws"))))
Theorem:
(defthm smtp-cst-month-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"") (or (smtp-cst-list-list-conc-matchp cstss "\"Jan\"") (smtp-cst-list-list-conc-matchp cstss "\"Feb\"") (smtp-cst-list-list-conc-matchp cstss "\"Mar\"") (smtp-cst-list-list-conc-matchp cstss "\"Apr\"") (smtp-cst-list-list-conc-matchp cstss "\"May\"") (smtp-cst-list-list-conc-matchp cstss "\"Jun\"") (smtp-cst-list-list-conc-matchp cstss "\"Jul\"") (smtp-cst-list-list-conc-matchp cstss "\"Aug\"") (smtp-cst-list-list-conc-matchp cstss "\"Sep\"") (smtp-cst-list-list-conc-matchp cstss "\"Oct\"") (smtp-cst-list-list-conc-matchp cstss "\"Nov\"") (smtp-cst-list-list-conc-matchp cstss "\"Dec\""))))
Theorem:
(defthm smtp-cst-msg-id-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]"))))
Theorem:
(defthm smtp-cst-id-left-concs (implies (smtp-cst-list-list-alt-matchp cstss "dot-atom-text / obs-id-left") (or (smtp-cst-list-list-conc-matchp cstss "dot-atom-text") (smtp-cst-list-list-conc-matchp cstss "obs-id-left"))))
Theorem:
(defthm smtp-cst-dot-atom-text-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*atext *( \".\" 1*atext )") (or (smtp-cst-list-list-conc-matchp cstss "1*atext *( \".\" 1*atext )"))))
Theorem:
(defthm smtp-cst-id-right-concs (implies (smtp-cst-list-list-alt-matchp cstss "dot-atom-text / no-fold-literal / obs-id-right") (or (smtp-cst-list-list-conc-matchp cstss "dot-atom-text") (smtp-cst-list-list-conc-matchp cstss "no-fold-literal") (smtp-cst-list-list-conc-matchp cstss "obs-id-right"))))
Theorem:
(defthm smtp-cst-no-fold-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"[\" *dtext \"]\"") (or (smtp-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\""))))
Theorem:
(defthm smtp-cst-dtext-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d33-90 / %d94-126 / obs-dtext") (or (smtp-cst-list-list-conc-matchp cstss "%d33-90") (smtp-cst-list-list-conc-matchp cstss "%d94-126") (smtp-cst-list-list-conc-matchp cstss "obs-dtext"))))
Theorem:
(defthm smtp-cst-obs-ctext-concs (implies (smtp-cst-list-list-alt-matchp cstss "obs-no-ws-ctl") (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-day-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 1*2digit [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 1*2digit [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-day-of-week-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] day-name [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] day-name [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-dtext-concs (implies (smtp-cst-list-list-alt-matchp cstss "obs-no-ws-ctl / quoted-pair") (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))))
Theorem:
(defthm smtp-cst-obs-fws-concs (implies (smtp-cst-list-list-alt-matchp cstss "1*wsp *( crlf 1*wsp )") (or (smtp-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )"))))
Theorem:
(defthm smtp-cst-obs-id-left-concs (implies (smtp-cst-list-list-alt-matchp cstss "imf-local-part") (or (smtp-cst-list-list-conc-matchp cstss "imf-local-part"))))
Theorem:
(defthm smtp-cst-imf-local-part-concs (implies (smtp-cst-list-list-alt-matchp cstss "dot-atom / imf-quoted-string / obs-local-part") (or (smtp-cst-list-list-conc-matchp cstss "dot-atom") (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string") (smtp-cst-list-list-conc-matchp cstss "obs-local-part"))))
Theorem:
(defthm smtp-cst-dot-atom-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] dot-atom-text [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] dot-atom-text [ cfws ]"))))
Theorem:
(defthm smtp-cst-imf-quoted-string-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-id-right-concs (implies (smtp-cst-list-list-alt-matchp cstss "imf-domain") (or (smtp-cst-list-list-conc-matchp cstss "imf-domain"))))
Theorem:
(defthm smtp-cst-imf-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "dot-atom / domain-literal / obs-domain") (or (smtp-cst-list-list-conc-matchp cstss "dot-atom") (smtp-cst-list-list-conc-matchp cstss "domain-literal") (smtp-cst-list-list-conc-matchp cstss "obs-domain"))))
Theorem:
(defthm smtp-cst-domain-literal-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-domain-concs (implies (smtp-cst-list-list-alt-matchp cstss "imf-atom *( \".\" imf-atom )") (or (smtp-cst-list-list-conc-matchp cstss "imf-atom *( \".\" imf-atom )"))))
Theorem:
(defthm smtp-cst-imf-atom-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 1*atext [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 1*atext [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-local-part-concs (implies (smtp-cst-list-list-alt-matchp cstss "word *( \".\" word )") (or (smtp-cst-list-list-conc-matchp cstss "word *( \".\" word )"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d1-8 / %d11 / %d12 / %d14-31 / %d127") (or (smtp-cst-list-list-conc-matchp cstss "%d1-8") (smtp-cst-list-list-conc-matchp cstss "%d11") (smtp-cst-list-list-conc-matchp cstss "%d12") (smtp-cst-list-list-conc-matchp cstss "%d14-31") (smtp-cst-list-list-conc-matchp cstss "%d127"))))
Theorem:
(defthm smtp-cst-qcontent-concs (implies (smtp-cst-list-list-alt-matchp cstss "qtext / quoted-pair") (or (smtp-cst-list-list-conc-matchp cstss "qtext") (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))))
Theorem:
(defthm smtp-cst-qtext-concs (implies (smtp-cst-list-list-alt-matchp cstss "%d33 / %d35-91 / %d93-126 / obs-qtext") (or (smtp-cst-list-list-conc-matchp cstss "%d33") (smtp-cst-list-list-conc-matchp cstss "%d35-91") (smtp-cst-list-list-conc-matchp cstss "%d93-126") (smtp-cst-list-list-conc-matchp cstss "obs-qtext"))))
Theorem:
(defthm smtp-cst-obs-qtext-concs (implies (smtp-cst-list-list-alt-matchp cstss "obs-no-ws-ctl") (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-quoted-pair-concs (implies (smtp-cst-list-list-alt-matchp cstss "( \"\\\" ( vchar / wsp ) ) / obs-qp") (or (smtp-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )") (smtp-cst-list-list-conc-matchp cstss "obs-qp"))))
Theorem:
(defthm smtp-cst-obs-qp-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )") (or (smtp-cst-list-list-conc-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )"))))
Theorem:
(defthm smtp-cst-time-concs (implies (smtp-cst-list-list-alt-matchp cstss "time-of-day zone") (or (smtp-cst-list-list-conc-matchp cstss "time-of-day zone"))))
Theorem:
(defthm smtp-cst-time-of-day-concs (implies (smtp-cst-list-list-alt-matchp cstss "hour \":\" minute [ \":\" second ]") (or (smtp-cst-list-list-conc-matchp cstss "hour \":\" minute [ \":\" second ]"))))
Theorem:
(defthm smtp-cst-hour-concs (implies (smtp-cst-list-list-alt-matchp cstss "2digit / obs-hour") (or (smtp-cst-list-list-conc-matchp cstss "2digit") (smtp-cst-list-list-conc-matchp cstss "obs-hour"))))
Theorem:
(defthm smtp-cst-minute-concs (implies (smtp-cst-list-list-alt-matchp cstss "2digit / obs-minute") (or (smtp-cst-list-list-conc-matchp cstss "2digit") (smtp-cst-list-list-conc-matchp cstss "obs-minute"))))
Theorem:
(defthm smtp-cst-obs-hour-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm smtp-cst-obs-minute-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm smtp-cst-second-concs (implies (smtp-cst-list-list-alt-matchp cstss "2digit / obs-second") (or (smtp-cst-list-list-conc-matchp cstss "2digit") (smtp-cst-list-list-conc-matchp cstss "obs-second"))))
Theorem:
(defthm smtp-cst-obs-second-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm smtp-cst-word-concs (implies (smtp-cst-list-list-alt-matchp cstss "imf-atom / imf-quoted-string") (or (smtp-cst-list-list-conc-matchp cstss "imf-atom") (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-year-concs (implies (smtp-cst-list-list-alt-matchp cstss "( fws 4*digit fws ) / obs-year") (or (smtp-cst-list-list-conc-matchp cstss "( fws 4*digit fws )") (smtp-cst-list-list-conc-matchp cstss "obs-year"))))
Theorem:
(defthm smtp-cst-obs-year-concs (implies (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2*digit [ cfws ]") (or (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2*digit [ cfws ]"))))
Theorem:
(defthm smtp-cst-zone-concs (implies (smtp-cst-list-list-alt-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone") (or (smtp-cst-list-list-conc-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit )") (smtp-cst-list-list-conc-matchp cstss "obs-zone"))))
Theorem:
(defthm smtp-cst-obs-zone-concs (implies (smtp-cst-list-list-alt-matchp cstss "\"UT\" / \"GMT\" / \"EST\" / \"EDT\" / \"CST\" / \"CDT\" / \"MST\" / \"MDT\" / \"PST\" / \"PDT\" / %d65-73 / %d75-90 / %d97-105 / %d107-122") (or (smtp-cst-list-list-conc-matchp cstss "\"UT\"") (smtp-cst-list-list-conc-matchp cstss "\"GMT\"") (smtp-cst-list-list-conc-matchp cstss "\"EST\"") (smtp-cst-list-list-conc-matchp cstss "\"EDT\"") (smtp-cst-list-list-conc-matchp cstss "\"CST\"") (smtp-cst-list-list-conc-matchp cstss "\"CDT\"") (smtp-cst-list-list-conc-matchp cstss "\"MST\"") (smtp-cst-list-list-conc-matchp cstss "\"MDT\"") (smtp-cst-list-list-conc-matchp cstss "\"PST\"") (smtp-cst-list-list-conc-matchp cstss "\"PDT\"") (smtp-cst-list-list-conc-matchp cstss "%d65-73") (smtp-cst-list-list-conc-matchp cstss "%d75-90") (smtp-cst-list-list-conc-matchp cstss "%d97-105") (smtp-cst-list-list-conc-matchp cstss "%d107-122"))))
Theorem:
(defthm smtp-cst-alpha-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x41-5A / %x61-7A") (or (smtp-cst-list-list-conc-matchp cstss "%x41-5A") (smtp-cst-list-list-conc-matchp cstss "%x61-7A"))))
Theorem:
(defthm smtp-cst-cr-concs (implies (smtp-cst-list-list-alt-matchp cstss "%xD") (or (smtp-cst-list-list-conc-matchp cstss "%xD"))))
Theorem:
(defthm smtp-cst-crlf-concs (implies (smtp-cst-list-list-alt-matchp cstss "cr lf") (or (smtp-cst-list-list-conc-matchp cstss "cr lf"))))
Theorem:
(defthm smtp-cst-digit-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x30-39") (or (smtp-cst-list-list-conc-matchp cstss "%x30-39"))))
Theorem:
(defthm smtp-cst-dquote-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x22") (or (smtp-cst-list-list-conc-matchp cstss "%x22"))))
Theorem:
(defthm smtp-cst-hexdig-concs (implies (smtp-cst-list-list-alt-matchp cstss "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"") (or (smtp-cst-list-list-conc-matchp cstss "digit") (smtp-cst-list-list-conc-matchp cstss "\"A\"") (smtp-cst-list-list-conc-matchp cstss "\"B\"") (smtp-cst-list-list-conc-matchp cstss "\"C\"") (smtp-cst-list-list-conc-matchp cstss "\"D\"") (smtp-cst-list-list-conc-matchp cstss "\"E\"") (smtp-cst-list-list-conc-matchp cstss "\"F\""))))
Theorem:
(defthm smtp-cst-lf-concs (implies (smtp-cst-list-list-alt-matchp cstss "%xA") (or (smtp-cst-list-list-conc-matchp cstss "%xA"))))
Theorem:
(defthm smtp-cst-sp-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x20") (or (smtp-cst-list-list-conc-matchp cstss "%x20"))))
Theorem:
(defthm smtp-cst-vchar-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x21-7E") (or (smtp-cst-list-list-conc-matchp cstss "%x21-7E"))))
Theorem:
(defthm smtp-cst-wsp-concs (implies (smtp-cst-list-list-alt-matchp cstss "sp / htab") (or (smtp-cst-list-list-conc-matchp cstss "sp") (smtp-cst-list-list-conc-matchp cstss "htab"))))
Theorem:
(defthm smtp-cst-htab-concs (implies (smtp-cst-list-list-alt-matchp cstss "%x9") (or (smtp-cst-list-list-conc-matchp cstss "%x9"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( \"250\" sp domain [ sp ehlo-greet ] crlf )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( \"250\" sp domain [ sp ehlo-greet ] crlf )"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))
Theorem:
(defthm smtp-cst-ehlo-greet-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*( %d0-9 / %d11-12 / %d14-127 )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*( %d0-9 / %d11-12 / %d14-127 )"))))
Theorem:
(defthm smtp-cst-ehlo-param-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*( %d33-126 )"))))
Theorem:
(defthm smtp-cst-reverse-path-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "path") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "path"))))
Theorem:
(defthm smtp-cst-reverse-path-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"<>\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"<>\""))))
Theorem:
(defthm smtp-cst-forward-path-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "path") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "path"))))
Theorem:
(defthm smtp-cst-esmtp-value-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*( %d33-60 / %d62-126 )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*( %d33-60 / %d62-126 )"))))
Theorem:
(defthm smtp-cst-keyword-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "ldh-str") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ldh-str"))))
Theorem:
(defthm smtp-cst-argument-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm smtp-cst-let-dig-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm smtp-cst-let-dig-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm smtp-cst-local-part-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "dot-string") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "dot-string"))))
Theorem:
(defthm smtp-cst-local-part-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-string") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-string"))))
Theorem:
(defthm smtp-cst-atom-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*atext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*atext"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "qtextsmtp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "qtextsmtp"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-pairsmtp"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d32-33") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d32-33"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d35-91") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d35-91"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d93-126"))))
Theorem:
(defthm smtp-cst-string-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm smtp-cst-string-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-string") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-string"))))
Theorem:
(defthm smtp-cst-standardized-tag-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "ldh-str") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ldh-str"))))
Theorem:
(defthm smtp-cst-dcontent-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d33-90") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d33-90"))))
Theorem:
(defthm smtp-cst-dcontent-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d94-126") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d94-126"))))
Theorem:
(defthm smtp-cst-snum-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*3digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*3digit"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "ipv6-full") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ipv6-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "ipv6-comp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ipv6-comp"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ipv6v4-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ipv6v4-comp"))))
Theorem:
(defthm smtp-cst-ipv6-hex-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*4hexdig") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*4hexdig"))))
Theorem:
(defthm smtp-cst-greeting-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )"))))
Theorem:
(defthm smtp-cst-greeting-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))
Theorem:
(defthm smtp-cst-textstring-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "1*( %d9 / %d32-126 )"))))
Theorem:
(defthm smtp-cst-extended-domain-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "domain") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "domain"))))
Theorem:
(defthm smtp-cst-extended-domain-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "( domain fws \"(\" tcp-info \")\" )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( domain fws \"(\" tcp-info \")\" )"))))
Theorem:
(defthm smtp-cst-extended-domain-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "( address-literal fws \"(\" tcp-info \")\" )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( address-literal fws \"(\" tcp-info \")\" )"))))
Theorem:
(defthm smtp-cst-tcp-info-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "address-literal") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "address-literal"))))
Theorem:
(defthm smtp-cst-tcp-info-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "( domain fws address-literal )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( domain fws address-literal )"))))
Theorem:
(defthm smtp-cst-link-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"TCP\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"TCP\""))))
Theorem:
(defthm smtp-cst-link-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "addtl-link") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "addtl-link"))))
Theorem:
(defthm smtp-cst-addtl-link-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm smtp-cst-protocol-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"ESMTP\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"ESMTP\""))))
Theorem:
(defthm smtp-cst-protocol-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"SMTP\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"SMTP\""))))
Theorem:
(defthm smtp-cst-protocol-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "attdl-protocol") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "attdl-protocol"))))
Theorem:
(defthm smtp-cst-attdl-protocol-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm smtp-cst-atext-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm smtp-cst-atext-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm smtp-cst-atext-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"!\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"!\""))))
Theorem:
(defthm smtp-cst-atext-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"#\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"#\""))))
Theorem:
(defthm smtp-cst-atext-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"$\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"$\""))))
Theorem:
(defthm smtp-cst-atext-conc6-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"%\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"%\""))))
Theorem:
(defthm smtp-cst-atext-conc7-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"&\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"&\""))))
Theorem:
(defthm smtp-cst-atext-conc8-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"'\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"'\""))))
Theorem:
(defthm smtp-cst-atext-conc9-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm smtp-cst-atext-conc10-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"+\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"+\""))))
Theorem:
(defthm smtp-cst-atext-conc11-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"-\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"-\""))))
Theorem:
(defthm smtp-cst-atext-conc12-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"/\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"/\""))))
Theorem:
(defthm smtp-cst-atext-conc13-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"=\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"=\""))))
Theorem:
(defthm smtp-cst-atext-conc14-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"?\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"?\""))))
Theorem:
(defthm smtp-cst-atext-conc15-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"^\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"^\""))))
Theorem:
(defthm smtp-cst-atext-conc16-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"_\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"_\""))))
Theorem:
(defthm smtp-cst-atext-conc17-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"`\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"`\""))))
Theorem:
(defthm smtp-cst-atext-conc18-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"{\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"{\""))))
Theorem:
(defthm smtp-cst-atext-conc19-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"|\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"|\""))))
Theorem:
(defthm smtp-cst-atext-conc20-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"}\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"}\""))))
Theorem:
(defthm smtp-cst-atext-conc21-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"~\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"~\""))))
Theorem:
(defthm smtp-cst-cfws-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( 1*( [ fws ] comment ) [ fws ] )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( 1*( [ fws ] comment ) [ fws ] )"))))
Theorem:
(defthm smtp-cst-cfws-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "fws") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "fws"))))
Theorem:
(defthm smtp-cst-ccontent-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "ctext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "ctext"))))
Theorem:
(defthm smtp-cst-ccontent-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm smtp-cst-ccontent-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "comment") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "comment"))))
Theorem:
(defthm smtp-cst-ctext-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d33-39") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d33-39"))))
Theorem:
(defthm smtp-cst-ctext-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d42-91") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d42-91"))))
Theorem:
(defthm smtp-cst-ctext-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d93-126"))))
Theorem:
(defthm smtp-cst-ctext-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-ctext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-ctext"))))
Theorem:
(defthm smtp-cst-day-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( [ fws ] 1*2digit fws )"))))
Theorem:
(defthm smtp-cst-day-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-day") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-day"))))
Theorem:
(defthm smtp-cst-day-of-week-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( [ fws ] day-name )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( [ fws ] day-name )"))))
Theorem:
(defthm smtp-cst-day-of-week-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-day-of-week") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-day-of-week"))))
Theorem:
(defthm smtp-cst-day-name-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Mon\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Mon\""))))
Theorem:
(defthm smtp-cst-day-name-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Tue\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Tue\""))))
Theorem:
(defthm smtp-cst-day-name-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Wed\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Wed\""))))
Theorem:
(defthm smtp-cst-day-name-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Thu\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Thu\""))))
Theorem:
(defthm smtp-cst-day-name-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Fri\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Fri\""))))
Theorem:
(defthm smtp-cst-day-name-conc6-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Sat\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Sat\""))))
Theorem:
(defthm smtp-cst-day-name-conc7-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Sun\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Sun\""))))
Theorem:
(defthm smtp-cst-fws-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( [ *wsp crlf ] 1*wsp )"))))
Theorem:
(defthm smtp-cst-fws-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-fws") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-fws"))))
Theorem:
(defthm smtp-cst-month-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Jan\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Jan\""))))
Theorem:
(defthm smtp-cst-month-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Feb\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Feb\""))))
Theorem:
(defthm smtp-cst-month-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Mar\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Mar\""))))
Theorem:
(defthm smtp-cst-month-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Apr\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Apr\""))))
Theorem:
(defthm smtp-cst-month-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"May\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"May\""))))
Theorem:
(defthm smtp-cst-month-conc6-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Jun\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Jun\""))))
Theorem:
(defthm smtp-cst-month-conc7-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Jul\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Jul\""))))
Theorem:
(defthm smtp-cst-month-conc8-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Aug\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Aug\""))))
Theorem:
(defthm smtp-cst-month-conc9-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Sep\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Sep\""))))
Theorem:
(defthm smtp-cst-month-conc10-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Oct\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Oct\""))))
Theorem:
(defthm smtp-cst-month-conc11-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Nov\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Nov\""))))
Theorem:
(defthm smtp-cst-month-conc12-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"Dec\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"Dec\""))))
Theorem:
(defthm smtp-cst-id-left-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom-text") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-left-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-id-left") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-id-left"))))
Theorem:
(defthm smtp-cst-id-right-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom-text") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-right-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "no-fold-literal") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "no-fold-literal"))))
Theorem:
(defthm smtp-cst-id-right-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-id-right") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-id-right"))))
Theorem:
(defthm smtp-cst-dtext-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d33-90") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d33-90"))))
Theorem:
(defthm smtp-cst-dtext-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d94-126") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d94-126"))))
Theorem:
(defthm smtp-cst-dtext-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-dtext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-dtext"))))
Theorem:
(defthm smtp-cst-obs-ctext-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-dtext-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-dtext-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm smtp-cst-obs-id-left-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "imf-local-part") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "imf-local-part"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-local-part") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-local-part"))))
Theorem:
(defthm smtp-cst-obs-id-right-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "imf-domain") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "imf-domain"))))
Theorem:
(defthm smtp-cst-imf-domain-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-domain-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "domain-literal") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "domain-literal"))))
Theorem:
(defthm smtp-cst-imf-domain-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-domain") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-domain"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d1-8") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d1-8"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d11") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d11"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d12") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d12"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d14-31") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d14-31"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d127") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d127"))))
Theorem:
(defthm smtp-cst-qcontent-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "qtext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "qtext"))))
Theorem:
(defthm smtp-cst-qcontent-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm smtp-cst-qtext-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d33") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d33"))))
Theorem:
(defthm smtp-cst-qtext-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d35-91") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d35-91"))))
Theorem:
(defthm smtp-cst-qtext-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d93-126"))))
Theorem:
(defthm smtp-cst-qtext-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-qtext") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-qtext"))))
Theorem:
(defthm smtp-cst-obs-qtext-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-quoted-pair-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( \"\\\" ( vchar / wsp ) )"))))
Theorem:
(defthm smtp-cst-quoted-pair-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-qp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-qp"))))
Theorem:
(defthm smtp-cst-hour-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm smtp-cst-hour-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-hour") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-hour"))))
Theorem:
(defthm smtp-cst-minute-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm smtp-cst-minute-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-minute") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-minute"))))
Theorem:
(defthm smtp-cst-second-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm smtp-cst-second-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-second") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-second"))))
Theorem:
(defthm smtp-cst-word-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "imf-atom") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "imf-atom"))))
Theorem:
(defthm smtp-cst-word-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-year-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( fws 4*digit fws )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( fws 4*digit fws )"))))
Theorem:
(defthm smtp-cst-year-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-year") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-year"))))
Theorem:
(defthm smtp-cst-zone-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit )") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "( fws ( \"+\" / \"-\" ) 4digit )"))))
Theorem:
(defthm smtp-cst-zone-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "obs-zone") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "obs-zone"))))
Theorem:
(defthm smtp-cst-obs-zone-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"UT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"UT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"GMT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"GMT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"EST\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"EST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"EDT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"EDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"CST\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"CST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc6-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"CDT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"CDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc7-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"MST\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"MST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc8-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"MDT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"MDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc9-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"PST\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"PST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc10-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"PDT\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"PDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc11-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d65-73") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d65-73"))))
Theorem:
(defthm smtp-cst-obs-zone-conc12-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d75-90") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d75-90"))))
Theorem:
(defthm smtp-cst-obs-zone-conc13-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d97-105") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d97-105"))))
Theorem:
(defthm smtp-cst-obs-zone-conc14-matching (implies (smtp-cst-list-list-conc-matchp cstss "%d107-122") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%d107-122"))))
Theorem:
(defthm smtp-cst-alpha-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x41-5A") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x41-5A"))))
Theorem:
(defthm smtp-cst-alpha-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x61-7A") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x61-7A"))))
Theorem:
(defthm smtp-cst-cr-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%xD") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%xD"))))
Theorem:
(defthm smtp-cst-digit-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x30-39") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x30-39"))))
Theorem:
(defthm smtp-cst-dquote-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x22") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x22"))))
Theorem:
(defthm smtp-cst-hexdig-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm smtp-cst-hexdig-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"A\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"A\""))))
Theorem:
(defthm smtp-cst-hexdig-conc3-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"B\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"B\""))))
Theorem:
(defthm smtp-cst-hexdig-conc4-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"C\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"C\""))))
Theorem:
(defthm smtp-cst-hexdig-conc5-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"D\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"D\""))))
Theorem:
(defthm smtp-cst-hexdig-conc6-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"E\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"E\""))))
Theorem:
(defthm smtp-cst-hexdig-conc7-matching (implies (smtp-cst-list-list-conc-matchp cstss "\"F\"") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "\"F\""))))
Theorem:
(defthm smtp-cst-lf-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%xA") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%xA"))))
Theorem:
(defthm smtp-cst-sp-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x20") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x20"))))
Theorem:
(defthm smtp-cst-vchar-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x21-7E") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x21-7E"))))
Theorem:
(defthm smtp-cst-wsp-conc1-matching (implies (smtp-cst-list-list-conc-matchp cstss "sp") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "sp"))))
Theorem:
(defthm smtp-cst-wsp-conc2-matching (implies (smtp-cst-list-list-conc-matchp cstss "htab") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "htab"))))
Theorem:
(defthm smtp-cst-htab-conc-matching (implies (smtp-cst-list-list-conc-matchp cstss "%x9") (and (equal (len cstss) 1) (smtp-cst-list-rep-matchp (nth 0 cstss) "%x9"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( \"250\" sp domain [ sp ehlo-greet ] crlf )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( \"250\" sp domain [ sp ehlo-greet ] crlf )"))))
Theorem:
(defthm smtp-cst-ehlo-ok-rsp-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))
Theorem:
(defthm smtp-cst-reverse-path-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "path") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "path"))))
Theorem:
(defthm smtp-cst-reverse-path-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"<>\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"<>\""))))
Theorem:
(defthm smtp-cst-forward-path-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "path") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "path"))))
Theorem:
(defthm smtp-cst-keyword-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "ldh-str") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ldh-str"))))
Theorem:
(defthm smtp-cst-argument-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm smtp-cst-local-part-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "dot-string") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "dot-string"))))
Theorem:
(defthm smtp-cst-local-part-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-string") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-string"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "qtextsmtp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "qtextsmtp"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-pairsmtp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-pairsmtp"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d32-33") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d32-33"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d35-91") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d35-91"))))
Theorem:
(defthm smtp-cst-qtextsmtp-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d93-126") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d93-126"))))
Theorem:
(defthm smtp-cst-string-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm smtp-cst-string-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-string") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-string"))))
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "ldh-str") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ldh-str"))))
Theorem:
(defthm smtp-cst-dcontent-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d33-90") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d33-90"))))
Theorem:
(defthm smtp-cst-dcontent-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d94-126") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d94-126"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "ipv6-full") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ipv6-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "ipv6-comp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ipv6-comp"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "ipv6v4-full") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ipv6v4-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "ipv6v4-comp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ipv6v4-comp"))))
Theorem:
(defthm smtp-cst-greeting-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )"))))
Theorem:
(defthm smtp-cst-greeting-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))
Theorem:
(defthm smtp-cst-extended-domain-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "domain") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "domain"))))
Theorem:
(defthm smtp-cst-extended-domain-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "( domain fws \"(\" tcp-info \")\" )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( domain fws \"(\" tcp-info \")\" )"))))
Theorem:
(defthm smtp-cst-extended-domain-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "( address-literal fws \"(\" tcp-info \")\" )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( address-literal fws \"(\" tcp-info \")\" )"))))
Theorem:
(defthm smtp-cst-tcp-info-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "address-literal") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "address-literal"))))
Theorem:
(defthm smtp-cst-tcp-info-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "( domain fws address-literal )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( domain fws address-literal )"))))
Theorem:
(defthm smtp-cst-link-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"TCP\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"TCP\""))))
Theorem:
(defthm smtp-cst-link-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "addtl-link") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "addtl-link"))))
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm smtp-cst-protocol-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"ESMTP\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"ESMTP\""))))
Theorem:
(defthm smtp-cst-protocol-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"SMTP\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"SMTP\""))))
Theorem:
(defthm smtp-cst-protocol-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "attdl-protocol") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "attdl-protocol"))))
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm smtp-cst-atext-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm smtp-cst-atext-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm smtp-cst-atext-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"!\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"!\""))))
Theorem:
(defthm smtp-cst-atext-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"#\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"#\""))))
Theorem:
(defthm smtp-cst-atext-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"$\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"$\""))))
Theorem:
(defthm smtp-cst-atext-conc6-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"%\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"%\""))))
Theorem:
(defthm smtp-cst-atext-conc7-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"&\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"&\""))))
Theorem:
(defthm smtp-cst-atext-conc8-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"'\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"'\""))))
Theorem:
(defthm smtp-cst-atext-conc9-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm smtp-cst-atext-conc10-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"+\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"+\""))))
Theorem:
(defthm smtp-cst-atext-conc11-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"-\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"-\""))))
Theorem:
(defthm smtp-cst-atext-conc12-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"/\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"/\""))))
Theorem:
(defthm smtp-cst-atext-conc13-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"=\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"=\""))))
Theorem:
(defthm smtp-cst-atext-conc14-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"?\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"?\""))))
Theorem:
(defthm smtp-cst-atext-conc15-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"^\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"^\""))))
Theorem:
(defthm smtp-cst-atext-conc16-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"_\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"_\""))))
Theorem:
(defthm smtp-cst-atext-conc17-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"`\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"`\""))))
Theorem:
(defthm smtp-cst-atext-conc18-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"{\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"{\""))))
Theorem:
(defthm smtp-cst-atext-conc19-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"|\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"|\""))))
Theorem:
(defthm smtp-cst-atext-conc20-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"}\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"}\""))))
Theorem:
(defthm smtp-cst-atext-conc21-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"~\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"~\""))))
Theorem:
(defthm smtp-cst-cfws-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( 1*( [ fws ] comment ) [ fws ] )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( 1*( [ fws ] comment ) [ fws ] )"))))
Theorem:
(defthm smtp-cst-cfws-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "fws") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "fws"))))
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "ctext") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "ctext"))))
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "comment") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "comment"))))
Theorem:
(defthm smtp-cst-ctext-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d33-39") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d33-39"))))
Theorem:
(defthm smtp-cst-ctext-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d42-91") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d42-91"))))
Theorem:
(defthm smtp-cst-ctext-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d93-126") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d93-126"))))
Theorem:
(defthm smtp-cst-ctext-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-ctext") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-ctext"))))
Theorem:
(defthm smtp-cst-day-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( [ fws ] 1*2digit fws )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( [ fws ] 1*2digit fws )"))))
Theorem:
(defthm smtp-cst-day-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-day") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-day"))))
Theorem:
(defthm smtp-cst-day-of-week-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( [ fws ] day-name )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( [ fws ] day-name )"))))
Theorem:
(defthm smtp-cst-day-of-week-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-day-of-week") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-day-of-week"))))
Theorem:
(defthm smtp-cst-day-name-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Mon\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Mon\""))))
Theorem:
(defthm smtp-cst-day-name-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Tue\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Tue\""))))
Theorem:
(defthm smtp-cst-day-name-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Wed\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Wed\""))))
Theorem:
(defthm smtp-cst-day-name-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Thu\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Thu\""))))
Theorem:
(defthm smtp-cst-day-name-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Fri\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Fri\""))))
Theorem:
(defthm smtp-cst-day-name-conc6-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Sat\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Sat\""))))
Theorem:
(defthm smtp-cst-day-name-conc7-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Sun\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Sun\""))))
Theorem:
(defthm smtp-cst-fws-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( [ *wsp crlf ] 1*wsp )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( [ *wsp crlf ] 1*wsp )"))))
Theorem:
(defthm smtp-cst-fws-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-fws") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-fws"))))
Theorem:
(defthm smtp-cst-month-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Jan\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Jan\""))))
Theorem:
(defthm smtp-cst-month-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Feb\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Feb\""))))
Theorem:
(defthm smtp-cst-month-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Mar\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Mar\""))))
Theorem:
(defthm smtp-cst-month-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Apr\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Apr\""))))
Theorem:
(defthm smtp-cst-month-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"May\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"May\""))))
Theorem:
(defthm smtp-cst-month-conc6-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Jun\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Jun\""))))
Theorem:
(defthm smtp-cst-month-conc7-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Jul\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Jul\""))))
Theorem:
(defthm smtp-cst-month-conc8-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Aug\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Aug\""))))
Theorem:
(defthm smtp-cst-month-conc9-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Sep\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Sep\""))))
Theorem:
(defthm smtp-cst-month-conc10-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Oct\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Oct\""))))
Theorem:
(defthm smtp-cst-month-conc11-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Nov\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Nov\""))))
Theorem:
(defthm smtp-cst-month-conc12-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"Dec\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"Dec\""))))
Theorem:
(defthm smtp-cst-id-left-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "dot-atom-text") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-left-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-id-left") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-id-left"))))
Theorem:
(defthm smtp-cst-id-right-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "dot-atom-text") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-right-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "no-fold-literal") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "no-fold-literal"))))
Theorem:
(defthm smtp-cst-id-right-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-id-right") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-id-right"))))
Theorem:
(defthm smtp-cst-dtext-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d33-90") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d33-90"))))
Theorem:
(defthm smtp-cst-dtext-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d94-126") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d94-126"))))
Theorem:
(defthm smtp-cst-dtext-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-dtext") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-dtext"))))
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "imf-local-part") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "imf-local-part"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "dot-atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "imf-quoted-string") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-local-part") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-local-part"))))
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "imf-domain") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "imf-domain"))))
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "dot-atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "domain-literal") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "domain-literal"))))
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-domain") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-domain"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d1-8") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d1-8"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d11") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d11"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d12") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d12"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d14-31") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d14-31"))))
Theorem:
(defthm smtp-cst-obs-no-ws-ctl-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d127") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d127"))))
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "qtext") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "qtext"))))
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm smtp-cst-qtext-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d33") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d33"))))
Theorem:
(defthm smtp-cst-qtext-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d35-91") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d35-91"))))
Theorem:
(defthm smtp-cst-qtext-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d93-126") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d93-126"))))
Theorem:
(defthm smtp-cst-qtext-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-qtext") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-qtext"))))
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-quoted-pair-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( \"\\\" ( vchar / wsp ) )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( \"\\\" ( vchar / wsp ) )"))))
Theorem:
(defthm smtp-cst-quoted-pair-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-qp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-qp"))))
Theorem:
(defthm smtp-cst-hour-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-hour") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-hour"))))
Theorem:
(defthm smtp-cst-minute-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-minute") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-minute"))))
Theorem:
(defthm smtp-cst-second-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-second") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-second"))))
Theorem:
(defthm smtp-cst-word-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "imf-atom") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "imf-atom"))))
Theorem:
(defthm smtp-cst-word-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "imf-quoted-string") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-year-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( fws 4*digit fws )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( fws 4*digit fws )"))))
Theorem:
(defthm smtp-cst-year-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-year") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-year"))))
Theorem:
(defthm smtp-cst-zone-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "( fws ( \"+\" / \"-\" ) 4digit )") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "( fws ( \"+\" / \"-\" ) 4digit )"))))
Theorem:
(defthm smtp-cst-zone-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "obs-zone") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "obs-zone"))))
Theorem:
(defthm smtp-cst-obs-zone-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"UT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"UT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"GMT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"GMT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"EST\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"EST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"EDT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"EDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"CST\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"CST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc6-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"CDT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"CDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc7-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"MST\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"MST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc8-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"MDT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"MDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc9-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"PST\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"PST\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc10-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"PDT\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"PDT\""))))
Theorem:
(defthm smtp-cst-obs-zone-conc11-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d65-73") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d65-73"))))
Theorem:
(defthm smtp-cst-obs-zone-conc12-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d75-90") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d75-90"))))
Theorem:
(defthm smtp-cst-obs-zone-conc13-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d97-105") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d97-105"))))
Theorem:
(defthm smtp-cst-obs-zone-conc14-rep-matching (implies (smtp-cst-list-rep-matchp csts "%d107-122") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%d107-122"))))
Theorem:
(defthm smtp-cst-alpha-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x41-5A") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x41-5A"))))
Theorem:
(defthm smtp-cst-alpha-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x61-7A") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x61-7A"))))
Theorem:
(defthm smtp-cst-cr-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%xD") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%xD"))))
Theorem:
(defthm smtp-cst-digit-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x30-39") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x30-39"))))
Theorem:
(defthm smtp-cst-dquote-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x22") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x22"))))
Theorem:
(defthm smtp-cst-hexdig-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm smtp-cst-hexdig-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"A\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"A\""))))
Theorem:
(defthm smtp-cst-hexdig-conc3-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"B\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"B\""))))
Theorem:
(defthm smtp-cst-hexdig-conc4-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"C\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"C\""))))
Theorem:
(defthm smtp-cst-hexdig-conc5-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"D\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"D\""))))
Theorem:
(defthm smtp-cst-hexdig-conc6-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"E\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"E\""))))
Theorem:
(defthm smtp-cst-hexdig-conc7-rep-matching (implies (smtp-cst-list-rep-matchp csts "\"F\"") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "\"F\""))))
Theorem:
(defthm smtp-cst-lf-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%xA") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%xA"))))
Theorem:
(defthm smtp-cst-sp-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x20") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x20"))))
Theorem:
(defthm smtp-cst-vchar-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x21-7E") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x21-7E"))))
Theorem:
(defthm smtp-cst-wsp-conc1-rep-matching (implies (smtp-cst-list-rep-matchp csts "sp") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "sp"))))
Theorem:
(defthm smtp-cst-wsp-conc2-rep-matching (implies (smtp-cst-list-rep-matchp csts "htab") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "htab"))))
Theorem:
(defthm smtp-cst-htab-conc-rep-matching (implies (smtp-cst-list-rep-matchp csts "%x9") (and (equal (len csts) 1) (smtp-cst-matchp (nth 0 csts) "%x9"))))
Theorem:
(defthm smtp-cst-reverse-path-conc-equivs (implies (smtp-cst-matchp cst "reverse-path") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "path") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"<>\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm smtp-cst-let-dig-conc-equivs (implies (smtp-cst-matchp cst "let-dig") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "alpha") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "alpha"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "digit") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "digit"))))))
Theorem:
(defthm smtp-cst-local-part-conc-equivs (implies (smtp-cst-matchp cst "local-part") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-string"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string"))))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc-equivs (implies (smtp-cst-matchp cst "qcontentsmtp") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "qtextsmtp") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "qtextsmtp"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pairsmtp") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pairsmtp"))))))
Theorem:
(defthm smtp-cst-string-conc-equivs (implies (smtp-cst-matchp cst "string") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string"))))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc-equivs (implies (smtp-cst-matchp cst "ipv6-addr") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6-full") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6-full"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6-comp") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6-comp"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6v4-full") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6v4-full"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6v4-comp") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6v4-comp"))))))
Theorem:
(defthm smtp-cst-link-conc-equivs (implies (smtp-cst-matchp cst "link") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"TCP\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "addtl-link") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)))))
Theorem:
(defthm smtp-cst-ccontent-conc-equivs (implies (smtp-cst-matchp cst "ccontent") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ctext") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ctext"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "comment") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "comment"))))))
Theorem:
(defthm smtp-cst-id-left-conc-equivs (implies (smtp-cst-matchp cst "id-left") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom-text"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-left") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-id-left"))))))
Theorem:
(defthm smtp-cst-id-right-conc-equivs (implies (smtp-cst-matchp cst "id-right") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom-text"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "no-fold-literal") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "no-fold-literal"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-right") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-id-right"))))))
Theorem:
(defthm smtp-cst-obs-dtext-conc-equivs (implies (smtp-cst-matchp cst "obs-dtext") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-no-ws-ctl"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair"))))))
Theorem:
(defthm smtp-cst-imf-local-part-conc-equivs (implies (smtp-cst-matchp cst "imf-local-part") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-quoted-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-quoted-string"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-local-part") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-local-part"))))))
Theorem:
(defthm smtp-cst-imf-domain-conc-equivs (implies (smtp-cst-matchp cst "imf-domain") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "domain-literal") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "domain-literal"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-domain") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-domain"))))))
Theorem:
(defthm smtp-cst-qcontent-conc-equivs (implies (smtp-cst-matchp cst "qcontent") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "qtext") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "qtext"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair"))))))
Theorem:
(defthm smtp-cst-word-conc-equivs (implies (smtp-cst-matchp cst "word") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-atom") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-atom"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-quoted-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-quoted-string"))))))
Theorem:
(defthm smtp-cst-wsp-conc-equivs (implies (smtp-cst-matchp cst "wsp") (and (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "sp") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "sp"))) (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "htab") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "htab"))))))
Function:
(defun smtp-cst-let-dig-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "let-dig"))) (let ((__function__ 'smtp-cst-let-dig-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "alpha")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "digit")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-let-dig-conc? (b* ((number (smtp-cst-let-dig-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc?-possibilities (b* ((number (smtp-cst-let-dig-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-let-dig-conc? cst)))))
Theorem:
(defthm smtp-cst-let-dig-conc?-of-tree-fix-cst (equal (smtp-cst-let-dig-conc? (tree-fix cst)) (smtp-cst-let-dig-conc? cst)))
Theorem:
(defthm smtp-cst-let-dig-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc? cst) (smtp-cst-let-dig-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-let-dig-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "let-dig") (iff (equal (smtp-cst-let-dig-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "alpha"))))
Theorem:
(defthm smtp-cst-let-dig-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "let-dig") (iff (equal (smtp-cst-let-dig-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "digit"))))
Function:
(defun smtp-cst-local-part-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "local-part"))) (let ((__function__ 'smtp-cst-local-part-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-string")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-local-part-conc? (b* ((number (smtp-cst-local-part-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc?-possibilities (b* ((number (smtp-cst-local-part-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-local-part-conc? cst)))))
Theorem:
(defthm smtp-cst-local-part-conc?-of-tree-fix-cst (equal (smtp-cst-local-part-conc? (tree-fix cst)) (smtp-cst-local-part-conc? cst)))
Theorem:
(defthm smtp-cst-local-part-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc? cst) (smtp-cst-local-part-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-local-part-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "local-part") (iff (equal (smtp-cst-local-part-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-string"))))
Theorem:
(defthm smtp-cst-local-part-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "local-part") (iff (equal (smtp-cst-local-part-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string"))))
Function:
(defun smtp-cst-qcontentsmtp-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "qcontentsmtp"))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "qtextsmtp")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pairsmtp")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-qcontentsmtp-conc? (b* ((number (smtp-cst-qcontentsmtp-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc?-possibilities (b* ((number (smtp-cst-qcontentsmtp-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-qcontentsmtp-conc? cst)))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc?-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc? (tree-fix cst)) (smtp-cst-qcontentsmtp-conc? cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc? cst) (smtp-cst-qcontentsmtp-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "qcontentsmtp") (iff (equal (smtp-cst-qcontentsmtp-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "qtextsmtp"))))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "qcontentsmtp") (iff (equal (smtp-cst-qcontentsmtp-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pairsmtp"))))
Function:
(defun smtp-cst-string-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "string"))) (let ((__function__ 'smtp-cst-string-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-string-conc? (b* ((number (smtp-cst-string-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc?-possibilities (b* ((number (smtp-cst-string-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-string-conc? cst)))))
Theorem:
(defthm smtp-cst-string-conc?-of-tree-fix-cst (equal (smtp-cst-string-conc? (tree-fix cst)) (smtp-cst-string-conc? cst)))
Theorem:
(defthm smtp-cst-string-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc? cst) (smtp-cst-string-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-string-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "string") (iff (equal (smtp-cst-string-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom"))))
Theorem:
(defthm smtp-cst-string-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "string") (iff (equal (smtp-cst-string-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string"))))
Function:
(defun smtp-cst-ipv6-addr-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6-addr"))) (let ((__function__ 'smtp-cst-ipv6-addr-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6-full")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6-comp")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6v4-full")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv6v4-comp")) 4) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-ipv6-addr-conc? (b* ((number (smtp-cst-ipv6-addr-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-possibilities (b* ((number (smtp-cst-ipv6-addr-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-ipv6-addr-conc? cst)))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc? (tree-fix cst)) (smtp-cst-ipv6-addr-conc? cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc? cst) (smtp-cst-ipv6-addr-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "ipv6-addr") (iff (equal (smtp-cst-ipv6-addr-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "ipv6-addr") (iff (equal (smtp-cst-ipv6-addr-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6-comp"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-3-iff-match-conc (implies (smtp-cst-matchp cst "ipv6-addr") (iff (equal (smtp-cst-ipv6-addr-conc? cst) 3) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6v4-full"))))
Theorem:
(defthm smtp-cst-ipv6-addr-conc?-4-iff-match-conc (implies (smtp-cst-matchp cst "ipv6-addr") (iff (equal (smtp-cst-ipv6-addr-conc? cst) 4) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv6v4-comp"))))
Function:
(defun smtp-cst-ccontent-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ccontent"))) (let ((__function__ 'smtp-cst-ccontent-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ctext")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "comment")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-ccontent-conc? (b* ((number (smtp-cst-ccontent-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc?-possibilities (b* ((number (smtp-cst-ccontent-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-ccontent-conc? cst)))))
Theorem:
(defthm smtp-cst-ccontent-conc?-of-tree-fix-cst (equal (smtp-cst-ccontent-conc? (tree-fix cst)) (smtp-cst-ccontent-conc? cst)))
Theorem:
(defthm smtp-cst-ccontent-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc? cst) (smtp-cst-ccontent-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-ccontent-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "ccontent") (iff (equal (smtp-cst-ccontent-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ctext"))))
Theorem:
(defthm smtp-cst-ccontent-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "ccontent") (iff (equal (smtp-cst-ccontent-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Theorem:
(defthm smtp-cst-ccontent-conc?-3-iff-match-conc (implies (smtp-cst-matchp cst "ccontent") (iff (equal (smtp-cst-ccontent-conc? cst) 3) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "comment"))))
Function:
(defun smtp-cst-id-left-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "id-left"))) (let ((__function__ 'smtp-cst-id-left-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom-text")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-id-left")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-id-left-conc? (b* ((number (smtp-cst-id-left-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc?-possibilities (b* ((number (smtp-cst-id-left-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-id-left-conc? cst)))))
Theorem:
(defthm smtp-cst-id-left-conc?-of-tree-fix-cst (equal (smtp-cst-id-left-conc? (tree-fix cst)) (smtp-cst-id-left-conc? cst)))
Theorem:
(defthm smtp-cst-id-left-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc? cst) (smtp-cst-id-left-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-id-left-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "id-left") (iff (equal (smtp-cst-id-left-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-left-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "id-left") (iff (equal (smtp-cst-id-left-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-left"))))
Function:
(defun smtp-cst-id-right-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "id-right"))) (let ((__function__ 'smtp-cst-id-right-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom-text")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "no-fold-literal")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-id-right")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-id-right-conc? (b* ((number (smtp-cst-id-right-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc?-possibilities (b* ((number (smtp-cst-id-right-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-id-right-conc? cst)))))
Theorem:
(defthm smtp-cst-id-right-conc?-of-tree-fix-cst (equal (smtp-cst-id-right-conc? (tree-fix cst)) (smtp-cst-id-right-conc? cst)))
Theorem:
(defthm smtp-cst-id-right-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc? cst) (smtp-cst-id-right-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-id-right-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "id-right") (iff (equal (smtp-cst-id-right-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text"))))
Theorem:
(defthm smtp-cst-id-right-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "id-right") (iff (equal (smtp-cst-id-right-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "no-fold-literal"))))
Theorem:
(defthm smtp-cst-id-right-conc?-3-iff-match-conc (implies (smtp-cst-matchp cst "id-right") (iff (equal (smtp-cst-id-right-conc? cst) 3) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-right"))))
Function:
(defun smtp-cst-obs-dtext-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-dtext"))) (let ((__function__ 'smtp-cst-obs-dtext-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-no-ws-ctl")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-obs-dtext-conc? (b* ((number (smtp-cst-obs-dtext-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc?-possibilities (b* ((number (smtp-cst-obs-dtext-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-obs-dtext-conc? cst)))))
Theorem:
(defthm smtp-cst-obs-dtext-conc?-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc? (tree-fix cst)) (smtp-cst-obs-dtext-conc? cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc? cst) (smtp-cst-obs-dtext-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-obs-dtext-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "obs-dtext") (iff (equal (smtp-cst-obs-dtext-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl"))))
Theorem:
(defthm smtp-cst-obs-dtext-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "obs-dtext") (iff (equal (smtp-cst-obs-dtext-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Function:
(defun smtp-cst-imf-local-part-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "imf-local-part"))) (let ((__function__ 'smtp-cst-imf-local-part-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-quoted-string")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-local-part")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-imf-local-part-conc? (b* ((number (smtp-cst-imf-local-part-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc?-possibilities (b* ((number (smtp-cst-imf-local-part-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-imf-local-part-conc? cst)))))
Theorem:
(defthm smtp-cst-imf-local-part-conc?-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc? (tree-fix cst)) (smtp-cst-imf-local-part-conc? cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc? cst) (smtp-cst-imf-local-part-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-imf-local-part-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "imf-local-part") (iff (equal (smtp-cst-imf-local-part-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "imf-local-part") (iff (equal (smtp-cst-imf-local-part-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-quoted-string"))))
Theorem:
(defthm smtp-cst-imf-local-part-conc?-3-iff-match-conc (implies (smtp-cst-matchp cst "imf-local-part") (iff (equal (smtp-cst-imf-local-part-conc? cst) 3) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-local-part"))))
Function:
(defun smtp-cst-imf-domain-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "imf-domain"))) (let ((__function__ 'smtp-cst-imf-domain-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dot-atom")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "domain-literal")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-domain")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-imf-domain-conc? (b* ((number (smtp-cst-imf-domain-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc?-possibilities (b* ((number (smtp-cst-imf-domain-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-imf-domain-conc? cst)))))
Theorem:
(defthm smtp-cst-imf-domain-conc?-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc? (tree-fix cst)) (smtp-cst-imf-domain-conc? cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc? cst) (smtp-cst-imf-domain-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-imf-domain-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "imf-domain") (iff (equal (smtp-cst-imf-domain-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom"))))
Theorem:
(defthm smtp-cst-imf-domain-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "imf-domain") (iff (equal (smtp-cst-imf-domain-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "domain-literal"))))
Theorem:
(defthm smtp-cst-imf-domain-conc?-3-iff-match-conc (implies (smtp-cst-matchp cst "imf-domain") (iff (equal (smtp-cst-imf-domain-conc? cst) 3) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-domain"))))
Function:
(defun smtp-cst-qcontent-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "qcontent"))) (let ((__function__ 'smtp-cst-qcontent-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "qtext")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-pair")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-qcontent-conc? (b* ((number (smtp-cst-qcontent-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc?-possibilities (b* ((number (smtp-cst-qcontent-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-qcontent-conc? cst)))))
Theorem:
(defthm smtp-cst-qcontent-conc?-of-tree-fix-cst (equal (smtp-cst-qcontent-conc? (tree-fix cst)) (smtp-cst-qcontent-conc? cst)))
Theorem:
(defthm smtp-cst-qcontent-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc? cst) (smtp-cst-qcontent-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-qcontent-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "qcontent") (iff (equal (smtp-cst-qcontent-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "qtext"))))
Theorem:
(defthm smtp-cst-qcontent-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "qcontent") (iff (equal (smtp-cst-qcontent-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Function:
(defun smtp-cst-word-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "word"))) (let ((__function__ 'smtp-cst-word-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-atom")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "imf-quoted-string")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-word-conc? (b* ((number (smtp-cst-word-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc?-possibilities (b* ((number (smtp-cst-word-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-word-conc? cst)))))
Theorem:
(defthm smtp-cst-word-conc?-of-tree-fix-cst (equal (smtp-cst-word-conc? (tree-fix cst)) (smtp-cst-word-conc? cst)))
Theorem:
(defthm smtp-cst-word-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc? cst) (smtp-cst-word-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-word-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "word") (iff (equal (smtp-cst-word-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-atom"))))
Theorem:
(defthm smtp-cst-word-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "word") (iff (equal (smtp-cst-word-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "imf-quoted-string"))))
Function:
(defun smtp-cst-wsp-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "wsp"))) (let ((__function__ 'smtp-cst-wsp-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "sp")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "htab")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-smtp-cst-wsp-conc? (b* ((number (smtp-cst-wsp-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc?-possibilities (b* ((number (smtp-cst-wsp-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((smtp-cst-wsp-conc? cst)))))
Theorem:
(defthm smtp-cst-wsp-conc?-of-tree-fix-cst (equal (smtp-cst-wsp-conc? (tree-fix cst)) (smtp-cst-wsp-conc? cst)))
Theorem:
(defthm smtp-cst-wsp-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc? cst) (smtp-cst-wsp-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm smtp-cst-wsp-conc?-1-iff-match-conc (implies (smtp-cst-matchp cst "wsp") (iff (equal (smtp-cst-wsp-conc? cst) 1) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "sp"))))
Theorem:
(defthm smtp-cst-wsp-conc?-2-iff-match-conc (implies (smtp-cst-matchp cst "wsp") (iff (equal (smtp-cst-wsp-conc? cst) 2) (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "htab"))))
Function:
(defun smtp-cst-ehlo-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ehlo"))) (let ((__function__ 'smtp-cst-ehlo-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ehlo-conc (b* ((cstss (smtp-cst-ehlo-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-conc-match (implies (smtp-cst-matchp cst "ehlo") (b* ((cstss (smtp-cst-ehlo-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"EHLO\" sp ( domain / address-literal ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-conc-of-tree-fix-cst (equal (smtp-cst-ehlo-conc (tree-fix cst)) (smtp-cst-ehlo-conc cst)))
Theorem:
(defthm smtp-cst-ehlo-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ehlo-conc cst) (smtp-cst-ehlo-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-helo-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "helo"))) (let ((__function__ 'smtp-cst-helo-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-helo-conc (b* ((cstss (smtp-cst-helo-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-helo-conc-match (implies (smtp-cst-matchp cst "helo") (b* ((cstss (smtp-cst-helo-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"HELO\" sp domain crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-helo-conc-of-tree-fix-cst (equal (smtp-cst-helo-conc (tree-fix cst)) (smtp-cst-helo-conc cst)))
Theorem:
(defthm smtp-cst-helo-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-helo-conc cst) (smtp-cst-helo-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ehlo-greet-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ehlo-greet"))) (let ((__function__ 'smtp-cst-ehlo-greet-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ehlo-greet-conc (b* ((cstss (smtp-cst-ehlo-greet-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-greet-conc-match (implies (smtp-cst-matchp cst "ehlo-greet") (b* ((cstss (smtp-cst-ehlo-greet-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*( %d0-9 / %d11-12 / %d14-127 )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-greet-conc-of-tree-fix-cst (equal (smtp-cst-ehlo-greet-conc (tree-fix cst)) (smtp-cst-ehlo-greet-conc cst)))
Theorem:
(defthm smtp-cst-ehlo-greet-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ehlo-greet-conc cst) (smtp-cst-ehlo-greet-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ehlo-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ehlo-line"))) (let ((__function__ 'smtp-cst-ehlo-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ehlo-line-conc (b* ((cstss (smtp-cst-ehlo-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-line-conc-match (implies (smtp-cst-matchp cst "ehlo-line") (b* ((cstss (smtp-cst-ehlo-line-conc cst))) (smtp-cst-list-list-conc-matchp cstss "ehlo-keyword *( sp ehlo-param )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-line-conc-of-tree-fix-cst (equal (smtp-cst-ehlo-line-conc (tree-fix cst)) (smtp-cst-ehlo-line-conc cst)))
Theorem:
(defthm smtp-cst-ehlo-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ehlo-line-conc cst) (smtp-cst-ehlo-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ehlo-keyword-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ehlo-keyword"))) (let ((__function__ 'smtp-cst-ehlo-keyword-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ehlo-keyword-conc (b* ((cstss (smtp-cst-ehlo-keyword-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-keyword-conc-match (implies (smtp-cst-matchp cst "ehlo-keyword") (b* ((cstss (smtp-cst-ehlo-keyword-conc cst))) (smtp-cst-list-list-conc-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-keyword-conc-of-tree-fix-cst (equal (smtp-cst-ehlo-keyword-conc (tree-fix cst)) (smtp-cst-ehlo-keyword-conc cst)))
Theorem:
(defthm smtp-cst-ehlo-keyword-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ehlo-keyword-conc cst) (smtp-cst-ehlo-keyword-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ehlo-param-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ehlo-param"))) (let ((__function__ 'smtp-cst-ehlo-param-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ehlo-param-conc (b* ((cstss (smtp-cst-ehlo-param-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-param-conc-match (implies (smtp-cst-matchp cst "ehlo-param") (b* ((cstss (smtp-cst-ehlo-param-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ehlo-param-conc-of-tree-fix-cst (equal (smtp-cst-ehlo-param-conc (tree-fix cst)) (smtp-cst-ehlo-param-conc cst)))
Theorem:
(defthm smtp-cst-ehlo-param-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ehlo-param-conc cst) (smtp-cst-ehlo-param-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-mail-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "mail"))) (let ((__function__ 'smtp-cst-mail-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-mail-conc (b* ((cstss (smtp-cst-mail-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mail-conc-match (implies (smtp-cst-matchp cst "mail") (b* ((cstss (smtp-cst-mail-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mail-conc-of-tree-fix-cst (equal (smtp-cst-mail-conc (tree-fix cst)) (smtp-cst-mail-conc cst)))
Theorem:
(defthm smtp-cst-mail-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-mail-conc cst) (smtp-cst-mail-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-rcpt-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "rcpt"))) (let ((__function__ 'smtp-cst-rcpt-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-rcpt-conc (b* ((cstss (smtp-cst-rcpt-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rcpt-conc-match (implies (smtp-cst-matchp cst "rcpt") (b* ((cstss (smtp-cst-rcpt-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rcpt-conc-of-tree-fix-cst (equal (smtp-cst-rcpt-conc (tree-fix cst)) (smtp-cst-rcpt-conc cst)))
Theorem:
(defthm smtp-cst-rcpt-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-rcpt-conc cst) (smtp-cst-rcpt-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-data-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "data"))) (let ((__function__ 'smtp-cst-data-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-data-conc (b* ((cstss (smtp-cst-data-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-data-conc-match (implies (smtp-cst-matchp cst "data") (b* ((cstss (smtp-cst-data-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"DATA\" crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-data-conc-of-tree-fix-cst (equal (smtp-cst-data-conc (tree-fix cst)) (smtp-cst-data-conc cst)))
Theorem:
(defthm smtp-cst-data-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-data-conc cst) (smtp-cst-data-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-rset-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "rset"))) (let ((__function__ 'smtp-cst-rset-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-rset-conc (b* ((cstss (smtp-cst-rset-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rset-conc-match (implies (smtp-cst-matchp cst "rset") (b* ((cstss (smtp-cst-rset-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"RSET\" crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rset-conc-of-tree-fix-cst (equal (smtp-cst-rset-conc (tree-fix cst)) (smtp-cst-rset-conc cst)))
Theorem:
(defthm smtp-cst-rset-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-rset-conc cst) (smtp-cst-rset-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-vrfy-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "vrfy"))) (let ((__function__ 'smtp-cst-vrfy-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-vrfy-conc (b* ((cstss (smtp-cst-vrfy-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vrfy-conc-match (implies (smtp-cst-matchp cst "vrfy") (b* ((cstss (smtp-cst-vrfy-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"VRFY\" sp string crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vrfy-conc-of-tree-fix-cst (equal (smtp-cst-vrfy-conc (tree-fix cst)) (smtp-cst-vrfy-conc cst)))
Theorem:
(defthm smtp-cst-vrfy-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-vrfy-conc cst) (smtp-cst-vrfy-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-expn-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "expn"))) (let ((__function__ 'smtp-cst-expn-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-expn-conc (b* ((cstss (smtp-cst-expn-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-expn-conc-match (implies (smtp-cst-matchp cst "expn") (b* ((cstss (smtp-cst-expn-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"EXPN\" sp string crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-expn-conc-of-tree-fix-cst (equal (smtp-cst-expn-conc (tree-fix cst)) (smtp-cst-expn-conc cst)))
Theorem:
(defthm smtp-cst-expn-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-expn-conc cst) (smtp-cst-expn-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-help-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "help"))) (let ((__function__ 'smtp-cst-help-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-help-conc (b* ((cstss (smtp-cst-help-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-help-conc-match (implies (smtp-cst-matchp cst "help") (b* ((cstss (smtp-cst-help-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"HELP\" [ sp string ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-help-conc-of-tree-fix-cst (equal (smtp-cst-help-conc (tree-fix cst)) (smtp-cst-help-conc cst)))
Theorem:
(defthm smtp-cst-help-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-help-conc cst) (smtp-cst-help-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-noop-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "noop"))) (let ((__function__ 'smtp-cst-noop-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-noop-conc (b* ((cstss (smtp-cst-noop-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-noop-conc-match (implies (smtp-cst-matchp cst "noop") (b* ((cstss (smtp-cst-noop-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"NOOP\" [ sp string ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-noop-conc-of-tree-fix-cst (equal (smtp-cst-noop-conc (tree-fix cst)) (smtp-cst-noop-conc cst)))
Theorem:
(defthm smtp-cst-noop-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-noop-conc cst) (smtp-cst-noop-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-quit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "quit"))) (let ((__function__ 'smtp-cst-quit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-quit-conc (b* ((cstss (smtp-cst-quit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quit-conc-match (implies (smtp-cst-matchp cst "quit") (b* ((cstss (smtp-cst-quit-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"QUIT\" crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quit-conc-of-tree-fix-cst (equal (smtp-cst-quit-conc (tree-fix cst)) (smtp-cst-quit-conc cst)))
Theorem:
(defthm smtp-cst-quit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-quit-conc cst) (smtp-cst-quit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-forward-path-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "forward-path"))) (let ((__function__ 'smtp-cst-forward-path-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-forward-path-conc (b* ((cstss (smtp-cst-forward-path-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-match (implies (smtp-cst-matchp cst "forward-path") (b* ((cstss (smtp-cst-forward-path-conc cst))) (smtp-cst-list-list-conc-matchp cstss "path"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-of-tree-fix-cst (equal (smtp-cst-forward-path-conc (tree-fix cst)) (smtp-cst-forward-path-conc cst)))
Theorem:
(defthm smtp-cst-forward-path-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-forward-path-conc cst) (smtp-cst-forward-path-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-path-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "path"))) (let ((__function__ 'smtp-cst-path-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-path-conc (b* ((cstss (smtp-cst-path-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-path-conc-match (implies (smtp-cst-matchp cst "path") (b* ((cstss (smtp-cst-path-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"<\" [ a-d-l \":\" ] mailbox \">\""))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-path-conc-of-tree-fix-cst (equal (smtp-cst-path-conc (tree-fix cst)) (smtp-cst-path-conc cst)))
Theorem:
(defthm smtp-cst-path-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-path-conc cst) (smtp-cst-path-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-a-d-l-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "a-d-l"))) (let ((__function__ 'smtp-cst-a-d-l-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-a-d-l-conc (b* ((cstss (smtp-cst-a-d-l-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-a-d-l-conc-match (implies (smtp-cst-matchp cst "a-d-l") (b* ((cstss (smtp-cst-a-d-l-conc cst))) (smtp-cst-list-list-conc-matchp cstss "at-domain *( \",\" at-domain )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-a-d-l-conc-of-tree-fix-cst (equal (smtp-cst-a-d-l-conc (tree-fix cst)) (smtp-cst-a-d-l-conc cst)))
Theorem:
(defthm smtp-cst-a-d-l-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-a-d-l-conc cst) (smtp-cst-a-d-l-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-at-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "at-domain"))) (let ((__function__ 'smtp-cst-at-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-at-domain-conc (b* ((cstss (smtp-cst-at-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-at-domain-conc-match (implies (smtp-cst-matchp cst "at-domain") (b* ((cstss (smtp-cst-at-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"@\" domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-at-domain-conc-of-tree-fix-cst (equal (smtp-cst-at-domain-conc (tree-fix cst)) (smtp-cst-at-domain-conc cst)))
Theorem:
(defthm smtp-cst-at-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-at-domain-conc cst) (smtp-cst-at-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-mail-parameters-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "mail-parameters"))) (let ((__function__ 'smtp-cst-mail-parameters-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-mail-parameters-conc (b* ((cstss (smtp-cst-mail-parameters-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mail-parameters-conc-match (implies (smtp-cst-matchp cst "mail-parameters") (b* ((cstss (smtp-cst-mail-parameters-conc cst))) (smtp-cst-list-list-conc-matchp cstss "esmtp-param *( sp esmtp-param )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mail-parameters-conc-of-tree-fix-cst (equal (smtp-cst-mail-parameters-conc (tree-fix cst)) (smtp-cst-mail-parameters-conc cst)))
Theorem:
(defthm smtp-cst-mail-parameters-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-mail-parameters-conc cst) (smtp-cst-mail-parameters-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-rcpt-parameters-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "rcpt-parameters"))) (let ((__function__ 'smtp-cst-rcpt-parameters-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-rcpt-parameters-conc (b* ((cstss (smtp-cst-rcpt-parameters-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rcpt-parameters-conc-match (implies (smtp-cst-matchp cst "rcpt-parameters") (b* ((cstss (smtp-cst-rcpt-parameters-conc cst))) (smtp-cst-list-list-conc-matchp cstss "esmtp-param *( sp esmtp-param )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-rcpt-parameters-conc-of-tree-fix-cst (equal (smtp-cst-rcpt-parameters-conc (tree-fix cst)) (smtp-cst-rcpt-parameters-conc cst)))
Theorem:
(defthm smtp-cst-rcpt-parameters-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-rcpt-parameters-conc cst) (smtp-cst-rcpt-parameters-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-esmtp-param-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "esmtp-param"))) (let ((__function__ 'smtp-cst-esmtp-param-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-esmtp-param-conc (b* ((cstss (smtp-cst-esmtp-param-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-param-conc-match (implies (smtp-cst-matchp cst "esmtp-param") (b* ((cstss (smtp-cst-esmtp-param-conc cst))) (smtp-cst-list-list-conc-matchp cstss "esmtp-keyword [ \"=\" esmtp-value ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-param-conc-of-tree-fix-cst (equal (smtp-cst-esmtp-param-conc (tree-fix cst)) (smtp-cst-esmtp-param-conc cst)))
Theorem:
(defthm smtp-cst-esmtp-param-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-esmtp-param-conc cst) (smtp-cst-esmtp-param-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-esmtp-keyword-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "esmtp-keyword"))) (let ((__function__ 'smtp-cst-esmtp-keyword-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-esmtp-keyword-conc (b* ((cstss (smtp-cst-esmtp-keyword-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-keyword-conc-match (implies (smtp-cst-matchp cst "esmtp-keyword") (b* ((cstss (smtp-cst-esmtp-keyword-conc cst))) (smtp-cst-list-list-conc-matchp cstss "( alpha / digit ) *( alpha / digit / \"-\" )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-keyword-conc-of-tree-fix-cst (equal (smtp-cst-esmtp-keyword-conc (tree-fix cst)) (smtp-cst-esmtp-keyword-conc cst)))
Theorem:
(defthm smtp-cst-esmtp-keyword-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-esmtp-keyword-conc cst) (smtp-cst-esmtp-keyword-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-esmtp-value-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "esmtp-value"))) (let ((__function__ 'smtp-cst-esmtp-value-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-esmtp-value-conc (b* ((cstss (smtp-cst-esmtp-value-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-value-conc-match (implies (smtp-cst-matchp cst "esmtp-value") (b* ((cstss (smtp-cst-esmtp-value-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*( %d33-60 / %d62-126 )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-esmtp-value-conc-of-tree-fix-cst (equal (smtp-cst-esmtp-value-conc (tree-fix cst)) (smtp-cst-esmtp-value-conc cst)))
Theorem:
(defthm smtp-cst-esmtp-value-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-esmtp-value-conc cst) (smtp-cst-esmtp-value-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-keyword-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "keyword"))) (let ((__function__ 'smtp-cst-keyword-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-keyword-conc (b* ((cstss (smtp-cst-keyword-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-match (implies (smtp-cst-matchp cst "keyword") (b* ((cstss (smtp-cst-keyword-conc cst))) (smtp-cst-list-list-conc-matchp cstss "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-of-tree-fix-cst (equal (smtp-cst-keyword-conc (tree-fix cst)) (smtp-cst-keyword-conc cst)))
Theorem:
(defthm smtp-cst-keyword-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-keyword-conc cst) (smtp-cst-keyword-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-argument-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "argument"))) (let ((__function__ 'smtp-cst-argument-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-argument-conc (b* ((cstss (smtp-cst-argument-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-match (implies (smtp-cst-matchp cst "argument") (b* ((cstss (smtp-cst-argument-conc cst))) (smtp-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-of-tree-fix-cst (equal (smtp-cst-argument-conc (tree-fix cst)) (smtp-cst-argument-conc cst)))
Theorem:
(defthm smtp-cst-argument-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-argument-conc cst) (smtp-cst-argument-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "domain"))) (let ((__function__ 'smtp-cst-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-domain-conc (b* ((cstss (smtp-cst-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-domain-conc-match (implies (smtp-cst-matchp cst "domain") (b* ((cstss (smtp-cst-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "sub-domain *( \".\" sub-domain )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-domain-conc-of-tree-fix-cst (equal (smtp-cst-domain-conc (tree-fix cst)) (smtp-cst-domain-conc cst)))
Theorem:
(defthm smtp-cst-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-domain-conc cst) (smtp-cst-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-sub-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "sub-domain"))) (let ((__function__ 'smtp-cst-sub-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-sub-domain-conc (b* ((cstss (smtp-cst-sub-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sub-domain-conc-match (implies (smtp-cst-matchp cst "sub-domain") (b* ((cstss (smtp-cst-sub-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "let-dig [ ldh-str ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sub-domain-conc-of-tree-fix-cst (equal (smtp-cst-sub-domain-conc (tree-fix cst)) (smtp-cst-sub-domain-conc cst)))
Theorem:
(defthm smtp-cst-sub-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-sub-domain-conc cst) (smtp-cst-sub-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)))) (let ((__function__ 'smtp-cst-let-dig-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-let-dig-conc1 (b* ((cstss (smtp-cst-let-dig-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)) (b* ((cstss (smtp-cst-let-dig-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "alpha"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-of-tree-fix-cst (equal (smtp-cst-let-dig-conc1 (tree-fix cst)) (smtp-cst-let-dig-conc1 cst)))
Theorem:
(defthm smtp-cst-let-dig-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc1 cst) (smtp-cst-let-dig-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)))) (let ((__function__ 'smtp-cst-let-dig-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-let-dig-conc2 (b* ((cstss (smtp-cst-let-dig-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)) (b* ((cstss (smtp-cst-let-dig-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "digit"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-of-tree-fix-cst (equal (smtp-cst-let-dig-conc2 (tree-fix cst)) (smtp-cst-let-dig-conc2 cst)))
Theorem:
(defthm smtp-cst-let-dig-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc2 cst) (smtp-cst-let-dig-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ldh-str-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ldh-str"))) (let ((__function__ 'smtp-cst-ldh-str-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ldh-str-conc (b* ((cstss (smtp-cst-ldh-str-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ldh-str-conc-match (implies (smtp-cst-matchp cst "ldh-str") (b* ((cstss (smtp-cst-ldh-str-conc cst))) (smtp-cst-list-list-conc-matchp cstss "*( alpha / digit / \"-\" ) let-dig"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ldh-str-conc-of-tree-fix-cst (equal (smtp-cst-ldh-str-conc (tree-fix cst)) (smtp-cst-ldh-str-conc cst)))
Theorem:
(defthm smtp-cst-ldh-str-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ldh-str-conc cst) (smtp-cst-ldh-str-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-address-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "address-literal"))) (let ((__function__ 'smtp-cst-address-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-address-literal-conc (b* ((cstss (smtp-cst-address-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-address-literal-conc-match (implies (smtp-cst-matchp cst "address-literal") (b* ((cstss (smtp-cst-address-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-address-literal-conc-of-tree-fix-cst (equal (smtp-cst-address-literal-conc (tree-fix cst)) (smtp-cst-address-literal-conc cst)))
Theorem:
(defthm smtp-cst-address-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-address-literal-conc cst) (smtp-cst-address-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-mailbox-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "mailbox"))) (let ((__function__ 'smtp-cst-mailbox-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-mailbox-conc (b* ((cstss (smtp-cst-mailbox-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mailbox-conc-match (implies (smtp-cst-matchp cst "mailbox") (b* ((cstss (smtp-cst-mailbox-conc cst))) (smtp-cst-list-list-conc-matchp cstss "local-part \"@\" ( domain / address-literal )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-mailbox-conc-of-tree-fix-cst (equal (smtp-cst-mailbox-conc (tree-fix cst)) (smtp-cst-mailbox-conc cst)))
Theorem:
(defthm smtp-cst-mailbox-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-mailbox-conc cst) (smtp-cst-mailbox-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-local-part-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-local-part-conc1 (b* ((cstss (smtp-cst-local-part-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)) (b* ((cstss (smtp-cst-local-part-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "dot-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-of-tree-fix-cst (equal (smtp-cst-local-part-conc1 (tree-fix cst)) (smtp-cst-local-part-conc1 cst)))
Theorem:
(defthm smtp-cst-local-part-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc1 cst) (smtp-cst-local-part-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-local-part-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-local-part-conc2 (b* ((cstss (smtp-cst-local-part-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)) (b* ((cstss (smtp-cst-local-part-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-of-tree-fix-cst (equal (smtp-cst-local-part-conc2 (tree-fix cst)) (smtp-cst-local-part-conc2 cst)))
Theorem:
(defthm smtp-cst-local-part-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc2 cst) (smtp-cst-local-part-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dot-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dot-string"))) (let ((__function__ 'smtp-cst-dot-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-dot-string-conc (b* ((cstss (smtp-cst-dot-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-string-conc-match (implies (smtp-cst-matchp cst "dot-string") (b* ((cstss (smtp-cst-dot-string-conc cst))) (smtp-cst-list-list-conc-matchp cstss "atom *( \".\" atom )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-string-conc-of-tree-fix-cst (equal (smtp-cst-dot-string-conc (tree-fix cst)) (smtp-cst-dot-string-conc cst)))
Theorem:
(defthm smtp-cst-dot-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dot-string-conc cst) (smtp-cst-dot-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "atom"))) (let ((__function__ 'smtp-cst-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-atom-conc (b* ((cstss (smtp-cst-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-atom-conc-match (implies (smtp-cst-matchp cst "atom") (b* ((cstss (smtp-cst-atom-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*atext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-atom-conc-of-tree-fix-cst (equal (smtp-cst-atom-conc (tree-fix cst)) (smtp-cst-atom-conc cst)))
Theorem:
(defthm smtp-cst-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-atom-conc cst) (smtp-cst-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-quoted-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "quoted-string"))) (let ((__function__ 'smtp-cst-quoted-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-quoted-string-conc (b* ((cstss (smtp-cst-quoted-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quoted-string-conc-match (implies (smtp-cst-matchp cst "quoted-string") (b* ((cstss (smtp-cst-quoted-string-conc cst))) (smtp-cst-list-list-conc-matchp cstss "dquote *qcontentsmtp dquote"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quoted-string-conc-of-tree-fix-cst (equal (smtp-cst-quoted-string-conc (tree-fix cst)) (smtp-cst-quoted-string-conc cst)))
Theorem:
(defthm smtp-cst-quoted-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-quoted-string-conc cst) (smtp-cst-quoted-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-qcontentsmtp-conc1 (b* ((cstss (smtp-cst-qcontentsmtp-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)) (b* ((cstss (smtp-cst-qcontentsmtp-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "qtextsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc1 (tree-fix cst)) (smtp-cst-qcontentsmtp-conc1 cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc1 cst) (smtp-cst-qcontentsmtp-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-qcontentsmtp-conc2 (b* ((cstss (smtp-cst-qcontentsmtp-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)) (b* ((cstss (smtp-cst-qcontentsmtp-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc2 (tree-fix cst)) (smtp-cst-qcontentsmtp-conc2 cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc2 cst) (smtp-cst-qcontentsmtp-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-quoted-pairsmtp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "quoted-pairsmtp"))) (let ((__function__ 'smtp-cst-quoted-pairsmtp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-quoted-pairsmtp-conc (b* ((cstss (smtp-cst-quoted-pairsmtp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quoted-pairsmtp-conc-match (implies (smtp-cst-matchp cst "quoted-pairsmtp") (b* ((cstss (smtp-cst-quoted-pairsmtp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%d92 %d32-126"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-quoted-pairsmtp-conc-of-tree-fix-cst (equal (smtp-cst-quoted-pairsmtp-conc (tree-fix cst)) (smtp-cst-quoted-pairsmtp-conc cst)))
Theorem:
(defthm smtp-cst-quoted-pairsmtp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-quoted-pairsmtp-conc cst) (smtp-cst-quoted-pairsmtp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)))) (let ((__function__ 'smtp-cst-string-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-string-conc1 (b* ((cstss (smtp-cst-string-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)) (b* ((cstss (smtp-cst-string-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-of-tree-fix-cst (equal (smtp-cst-string-conc1 (tree-fix cst)) (smtp-cst-string-conc1 cst)))
Theorem:
(defthm smtp-cst-string-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc1 cst) (smtp-cst-string-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)))) (let ((__function__ 'smtp-cst-string-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-string-conc2 (b* ((cstss (smtp-cst-string-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)) (b* ((cstss (smtp-cst-string-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-of-tree-fix-cst (equal (smtp-cst-string-conc2 (tree-fix cst)) (smtp-cst-string-conc2 cst)))
Theorem:
(defthm smtp-cst-string-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc2 cst) (smtp-cst-string-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv4-address-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv4-address-literal"))) (let ((__function__ 'smtp-cst-ipv4-address-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv4-address-literal-conc (b* ((cstss (smtp-cst-ipv4-address-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv4-address-literal-conc-match (implies (smtp-cst-matchp cst "ipv4-address-literal") (b* ((cstss (smtp-cst-ipv4-address-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "snum 3( \".\" snum )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv4-address-literal-conc-of-tree-fix-cst (equal (smtp-cst-ipv4-address-literal-conc (tree-fix cst)) (smtp-cst-ipv4-address-literal-conc cst)))
Theorem:
(defthm smtp-cst-ipv4-address-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv4-address-literal-conc cst) (smtp-cst-ipv4-address-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-address-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6-address-literal"))) (let ((__function__ 'smtp-cst-ipv6-address-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-address-literal-conc (b* ((cstss (smtp-cst-ipv6-address-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-address-literal-conc-match (implies (smtp-cst-matchp cst "ipv6-address-literal") (b* ((cstss (smtp-cst-ipv6-address-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"IPv6:\" ipv6-addr"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-address-literal-conc-of-tree-fix-cst (equal (smtp-cst-ipv6-address-literal-conc (tree-fix cst)) (smtp-cst-ipv6-address-literal-conc cst)))
Theorem:
(defthm smtp-cst-ipv6-address-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-address-literal-conc cst) (smtp-cst-ipv6-address-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-general-address-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "general-address-literal"))) (let ((__function__ 'smtp-cst-general-address-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-general-address-literal-conc (b* ((cstss (smtp-cst-general-address-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-general-address-literal-conc-match (implies (smtp-cst-matchp cst "general-address-literal") (b* ((cstss (smtp-cst-general-address-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "standardized-tag \":\" 1*dcontent"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-general-address-literal-conc-of-tree-fix-cst (equal (smtp-cst-general-address-literal-conc (tree-fix cst)) (smtp-cst-general-address-literal-conc cst)))
Theorem:
(defthm smtp-cst-general-address-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-general-address-literal-conc cst) (smtp-cst-general-address-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-standardized-tag-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag"))) (let ((__function__ 'smtp-cst-standardized-tag-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-standardized-tag-conc (b* ((cstss (smtp-cst-standardized-tag-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-match (implies (smtp-cst-matchp cst "standardized-tag") (b* ((cstss (smtp-cst-standardized-tag-conc cst))) (smtp-cst-list-list-conc-matchp cstss "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-of-tree-fix-cst (equal (smtp-cst-standardized-tag-conc (tree-fix cst)) (smtp-cst-standardized-tag-conc cst)))
Theorem:
(defthm smtp-cst-standardized-tag-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-standardized-tag-conc cst) (smtp-cst-standardized-tag-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-snum-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "snum"))) (let ((__function__ 'smtp-cst-snum-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-snum-conc (b* ((cstss (smtp-cst-snum-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-snum-conc-match (implies (smtp-cst-matchp cst "snum") (b* ((cstss (smtp-cst-snum-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*3digit"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-snum-conc-of-tree-fix-cst (equal (smtp-cst-snum-conc (tree-fix cst)) (smtp-cst-snum-conc cst)))
Theorem:
(defthm smtp-cst-snum-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-snum-conc cst) (smtp-cst-snum-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc1 (b* ((cstss (smtp-cst-ipv6-addr-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)) (b* ((cstss (smtp-cst-ipv6-addr-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc1 (tree-fix cst)) (smtp-cst-ipv6-addr-conc1 cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc1 cst) (smtp-cst-ipv6-addr-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc2 (b* ((cstss (smtp-cst-ipv6-addr-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)) (b* ((cstss (smtp-cst-ipv6-addr-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc2 (tree-fix cst)) (smtp-cst-ipv6-addr-conc2 cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc2 cst) (smtp-cst-ipv6-addr-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc3 (b* ((cstss (smtp-cst-ipv6-addr-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)) (b* ((cstss (smtp-cst-ipv6-addr-conc3 cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc3 (tree-fix cst)) (smtp-cst-ipv6-addr-conc3 cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc3 cst) (smtp-cst-ipv6-addr-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc4 (b* ((cstss (smtp-cst-ipv6-addr-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)) (b* ((cstss (smtp-cst-ipv6-addr-conc4 cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc4 (tree-fix cst)) (smtp-cst-ipv6-addr-conc4 cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc4 cst) (smtp-cst-ipv6-addr-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-hex-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6-hex"))) (let ((__function__ 'smtp-cst-ipv6-hex-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-hex-conc (b* ((cstss (smtp-cst-ipv6-hex-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-hex-conc-match (implies (smtp-cst-matchp cst "ipv6-hex") (b* ((cstss (smtp-cst-ipv6-hex-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*4hexdig"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-hex-conc-of-tree-fix-cst (equal (smtp-cst-ipv6-hex-conc (tree-fix cst)) (smtp-cst-ipv6-hex-conc cst)))
Theorem:
(defthm smtp-cst-ipv6-hex-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-hex-conc cst) (smtp-cst-ipv6-hex-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-full-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6-full"))) (let ((__function__ 'smtp-cst-ipv6-full-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-full-conc (b* ((cstss (smtp-cst-ipv6-full-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-full-conc-match (implies (smtp-cst-matchp cst "ipv6-full") (b* ((cstss (smtp-cst-ipv6-full-conc cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6-hex 7( \":\" ipv6-hex )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-full-conc-of-tree-fix-cst (equal (smtp-cst-ipv6-full-conc (tree-fix cst)) (smtp-cst-ipv6-full-conc cst)))
Theorem:
(defthm smtp-cst-ipv6-full-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-full-conc cst) (smtp-cst-ipv6-full-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-comp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6-comp"))) (let ((__function__ 'smtp-cst-ipv6-comp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6-comp-conc (b* ((cstss (smtp-cst-ipv6-comp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-comp-conc-match (implies (smtp-cst-matchp cst "ipv6-comp") (b* ((cstss (smtp-cst-ipv6-comp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-comp-conc-of-tree-fix-cst (equal (smtp-cst-ipv6-comp-conc (tree-fix cst)) (smtp-cst-ipv6-comp-conc cst)))
Theorem:
(defthm smtp-cst-ipv6-comp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-comp-conc cst) (smtp-cst-ipv6-comp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6v4-full-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6v4-full"))) (let ((__function__ 'smtp-cst-ipv6v4-full-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6v4-full-conc (b* ((cstss (smtp-cst-ipv6v4-full-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6v4-full-conc-match (implies (smtp-cst-matchp cst "ipv6v4-full") (b* ((cstss (smtp-cst-ipv6v4-full-conc cst))) (smtp-cst-list-list-conc-matchp cstss "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6v4-full-conc-of-tree-fix-cst (equal (smtp-cst-ipv6v4-full-conc (tree-fix cst)) (smtp-cst-ipv6v4-full-conc cst)))
Theorem:
(defthm smtp-cst-ipv6v4-full-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6v4-full-conc cst) (smtp-cst-ipv6v4-full-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6v4-comp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "ipv6v4-comp"))) (let ((__function__ 'smtp-cst-ipv6v4-comp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ipv6v4-comp-conc (b* ((cstss (smtp-cst-ipv6v4-comp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6v4-comp-conc-match (implies (smtp-cst-matchp cst "ipv6v4-comp") (b* ((cstss (smtp-cst-ipv6v4-comp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6v4-comp-conc-of-tree-fix-cst (equal (smtp-cst-ipv6v4-comp-conc (tree-fix cst)) (smtp-cst-ipv6v4-comp-conc cst)))
Theorem:
(defthm smtp-cst-ipv6v4-comp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6v4-comp-conc cst) (smtp-cst-ipv6v4-comp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-textstring-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "textstring"))) (let ((__function__ 'smtp-cst-textstring-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-textstring-conc (b* ((cstss (smtp-cst-textstring-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-textstring-conc-match (implies (smtp-cst-matchp cst "textstring") (b* ((cstss (smtp-cst-textstring-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-textstring-conc-of-tree-fix-cst (equal (smtp-cst-textstring-conc (tree-fix cst)) (smtp-cst-textstring-conc cst)))
Theorem:
(defthm smtp-cst-textstring-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-textstring-conc cst) (smtp-cst-textstring-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-reply-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "reply-line"))) (let ((__function__ 'smtp-cst-reply-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-reply-line-conc (b* ((cstss (smtp-cst-reply-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-reply-line-conc-match (implies (smtp-cst-matchp cst "reply-line") (b* ((cstss (smtp-cst-reply-line-conc cst))) (smtp-cst-list-list-conc-matchp cstss "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-reply-line-conc-of-tree-fix-cst (equal (smtp-cst-reply-line-conc (tree-fix cst)) (smtp-cst-reply-line-conc cst)))
Theorem:
(defthm smtp-cst-reply-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-reply-line-conc cst) (smtp-cst-reply-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-reply-code-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "reply-code"))) (let ((__function__ 'smtp-cst-reply-code-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-reply-code-conc (b* ((cstss (smtp-cst-reply-code-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-reply-code-conc-match (implies (smtp-cst-matchp cst "reply-code") (b* ((cstss (smtp-cst-reply-code-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x32-35 %x30-35 %x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-reply-code-conc-of-tree-fix-cst (equal (smtp-cst-reply-code-conc (tree-fix cst)) (smtp-cst-reply-code-conc cst)))
Theorem:
(defthm smtp-cst-reply-code-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-reply-code-conc cst) (smtp-cst-reply-code-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-return-path-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "return-path-line"))) (let ((__function__ 'smtp-cst-return-path-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-return-path-line-conc (b* ((cstss (smtp-cst-return-path-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-return-path-line-conc-match (implies (smtp-cst-matchp cst "return-path-line") (b* ((cstss (smtp-cst-return-path-line-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"Return-Path:\" fws reverse-path crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-return-path-line-conc-of-tree-fix-cst (equal (smtp-cst-return-path-line-conc (tree-fix cst)) (smtp-cst-return-path-line-conc cst)))
Theorem:
(defthm smtp-cst-return-path-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-return-path-line-conc cst) (smtp-cst-return-path-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-time-stamp-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "time-stamp-line"))) (let ((__function__ 'smtp-cst-time-stamp-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-time-stamp-line-conc (b* ((cstss (smtp-cst-time-stamp-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-stamp-line-conc-match (implies (smtp-cst-matchp cst "time-stamp-line") (b* ((cstss (smtp-cst-time-stamp-line-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"Received:\" fws stamp crlf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-stamp-line-conc-of-tree-fix-cst (equal (smtp-cst-time-stamp-line-conc (tree-fix cst)) (smtp-cst-time-stamp-line-conc cst)))
Theorem:
(defthm smtp-cst-time-stamp-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-time-stamp-line-conc cst) (smtp-cst-time-stamp-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-stamp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "stamp"))) (let ((__function__ 'smtp-cst-stamp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-stamp-conc (b* ((cstss (smtp-cst-stamp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-stamp-conc-match (implies (smtp-cst-matchp cst "stamp") (b* ((cstss (smtp-cst-stamp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "from-domain by-domain opt-info [ cfws ] \";\" fws date-time"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-stamp-conc-of-tree-fix-cst (equal (smtp-cst-stamp-conc (tree-fix cst)) (smtp-cst-stamp-conc cst)))
Theorem:
(defthm smtp-cst-stamp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-stamp-conc cst) (smtp-cst-stamp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-from-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "from-domain"))) (let ((__function__ 'smtp-cst-from-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-from-domain-conc (b* ((cstss (smtp-cst-from-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-from-domain-conc-match (implies (smtp-cst-matchp cst "from-domain") (b* ((cstss (smtp-cst-from-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"FROM\" fws extended-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-from-domain-conc-of-tree-fix-cst (equal (smtp-cst-from-domain-conc (tree-fix cst)) (smtp-cst-from-domain-conc cst)))
Theorem:
(defthm smtp-cst-from-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-from-domain-conc cst) (smtp-cst-from-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-by-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "by-domain"))) (let ((__function__ 'smtp-cst-by-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-by-domain-conc (b* ((cstss (smtp-cst-by-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-by-domain-conc-match (implies (smtp-cst-matchp cst "by-domain") (b* ((cstss (smtp-cst-by-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws \"BY\" fws extended-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-by-domain-conc-of-tree-fix-cst (equal (smtp-cst-by-domain-conc (tree-fix cst)) (smtp-cst-by-domain-conc cst)))
Theorem:
(defthm smtp-cst-by-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-by-domain-conc cst) (smtp-cst-by-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-opt-info-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "opt-info"))) (let ((__function__ 'smtp-cst-opt-info-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-opt-info-conc (b* ((cstss (smtp-cst-opt-info-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-opt-info-conc-match (implies (smtp-cst-matchp cst "opt-info") (b* ((cstss (smtp-cst-opt-info-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-opt-info-conc-of-tree-fix-cst (equal (smtp-cst-opt-info-conc (tree-fix cst)) (smtp-cst-opt-info-conc cst)))
Theorem:
(defthm smtp-cst-opt-info-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-opt-info-conc cst) (smtp-cst-opt-info-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-via-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "via"))) (let ((__function__ 'smtp-cst-via-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-via-conc (b* ((cstss (smtp-cst-via-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-via-conc-match (implies (smtp-cst-matchp cst "via") (b* ((cstss (smtp-cst-via-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws \"VIA\" fws link"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-via-conc-of-tree-fix-cst (equal (smtp-cst-via-conc (tree-fix cst)) (smtp-cst-via-conc cst)))
Theorem:
(defthm smtp-cst-via-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-via-conc cst) (smtp-cst-via-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-with-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "with"))) (let ((__function__ 'smtp-cst-with-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-with-conc (b* ((cstss (smtp-cst-with-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-with-conc-match (implies (smtp-cst-matchp cst "with") (b* ((cstss (smtp-cst-with-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws \"WITH\" fws protocol"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-with-conc-of-tree-fix-cst (equal (smtp-cst-with-conc (tree-fix cst)) (smtp-cst-with-conc cst)))
Theorem:
(defthm smtp-cst-with-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-with-conc cst) (smtp-cst-with-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "id"))) (let ((__function__ 'smtp-cst-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-conc (b* ((cstss (smtp-cst-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-conc-match (implies (smtp-cst-matchp cst "id") (b* ((cstss (smtp-cst-id-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws \"ID\" fws ( atom / msg-id )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-conc-of-tree-fix-cst (equal (smtp-cst-id-conc (tree-fix cst)) (smtp-cst-id-conc cst)))
Theorem:
(defthm smtp-cst-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-conc cst) (smtp-cst-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-for-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "for"))) (let ((__function__ 'smtp-cst-for-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-for-conc (b* ((cstss (smtp-cst-for-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-for-conc-match (implies (smtp-cst-matchp cst "for") (b* ((cstss (smtp-cst-for-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws \"FOR\" fws ( path / mailbox )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-for-conc-of-tree-fix-cst (equal (smtp-cst-for-conc (tree-fix cst)) (smtp-cst-for-conc cst)))
Theorem:
(defthm smtp-cst-for-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-for-conc cst) (smtp-cst-for-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-additional-registered-clauses-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "additional-registered-clauses"))) (let ((__function__ 'smtp-cst-additional-registered-clauses-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-additional-registered-clauses-conc (b* ((cstss (smtp-cst-additional-registered-clauses-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-additional-registered-clauses-conc-match (implies (smtp-cst-matchp cst "additional-registered-clauses") (b* ((cstss (smtp-cst-additional-registered-clauses-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cfws atom fws string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-additional-registered-clauses-conc-of-tree-fix-cst (equal (smtp-cst-additional-registered-clauses-conc (tree-fix cst)) (smtp-cst-additional-registered-clauses-conc cst)))
Theorem:
(defthm smtp-cst-additional-registered-clauses-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-additional-registered-clauses-conc cst) (smtp-cst-additional-registered-clauses-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-addtl-link-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "addtl-link"))) (let ((__function__ 'smtp-cst-addtl-link-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-addtl-link-conc (b* ((cstss (smtp-cst-addtl-link-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-match (implies (smtp-cst-matchp cst "addtl-link") (b* ((cstss (smtp-cst-addtl-link-conc cst))) (smtp-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-of-tree-fix-cst (equal (smtp-cst-addtl-link-conc (tree-fix cst)) (smtp-cst-addtl-link-conc cst)))
Theorem:
(defthm smtp-cst-addtl-link-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-addtl-link-conc cst) (smtp-cst-addtl-link-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-attdl-protocol-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol"))) (let ((__function__ 'smtp-cst-attdl-protocol-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-attdl-protocol-conc (b* ((cstss (smtp-cst-attdl-protocol-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-match (implies (smtp-cst-matchp cst "attdl-protocol") (b* ((cstss (smtp-cst-attdl-protocol-conc cst))) (smtp-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-of-tree-fix-cst (equal (smtp-cst-attdl-protocol-conc (tree-fix cst)) (smtp-cst-attdl-protocol-conc cst)))
Theorem:
(defthm smtp-cst-attdl-protocol-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-attdl-protocol-conc cst) (smtp-cst-attdl-protocol-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-comment-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "comment"))) (let ((__function__ 'smtp-cst-comment-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-comment-conc (b* ((cstss (smtp-cst-comment-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-comment-conc-match (implies (smtp-cst-matchp cst "comment") (b* ((cstss (smtp-cst-comment-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-comment-conc-of-tree-fix-cst (equal (smtp-cst-comment-conc (tree-fix cst)) (smtp-cst-comment-conc cst)))
Theorem:
(defthm smtp-cst-comment-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-comment-conc cst) (smtp-cst-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ccontent-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ccontent-conc1 (b* ((cstss (smtp-cst-ccontent-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)) (b* ((cstss (smtp-cst-ccontent-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-of-tree-fix-cst (equal (smtp-cst-ccontent-conc1 (tree-fix cst)) (smtp-cst-ccontent-conc1 cst)))
Theorem:
(defthm smtp-cst-ccontent-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc1 cst) (smtp-cst-ccontent-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ccontent-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ccontent-conc2 (b* ((cstss (smtp-cst-ccontent-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)) (b* ((cstss (smtp-cst-ccontent-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-of-tree-fix-cst (equal (smtp-cst-ccontent-conc2 (tree-fix cst)) (smtp-cst-ccontent-conc2 cst)))
Theorem:
(defthm smtp-cst-ccontent-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc2 cst) (smtp-cst-ccontent-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ccontent-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-ccontent-conc3 (b* ((cstss (smtp-cst-ccontent-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)) (b* ((cstss (smtp-cst-ccontent-conc3 cst))) (smtp-cst-list-list-conc-matchp cstss "comment"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-of-tree-fix-cst (equal (smtp-cst-ccontent-conc3 (tree-fix cst)) (smtp-cst-ccontent-conc3 cst)))
Theorem:
(defthm smtp-cst-ccontent-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc3 cst) (smtp-cst-ccontent-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-date-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "date-time"))) (let ((__function__ 'smtp-cst-date-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-date-time-conc (b* ((cstss (smtp-cst-date-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-date-time-conc-match (implies (smtp-cst-matchp cst "date-time") (b* ((cstss (smtp-cst-date-time-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-date-time-conc-of-tree-fix-cst (equal (smtp-cst-date-time-conc (tree-fix cst)) (smtp-cst-date-time-conc cst)))
Theorem:
(defthm smtp-cst-date-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-date-time-conc cst) (smtp-cst-date-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "date"))) (let ((__function__ 'smtp-cst-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-date-conc (b* ((cstss (smtp-cst-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-date-conc-match (implies (smtp-cst-matchp cst "date") (b* ((cstss (smtp-cst-date-conc cst))) (smtp-cst-list-list-conc-matchp cstss "day month year"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-date-conc-of-tree-fix-cst (equal (smtp-cst-date-conc (tree-fix cst)) (smtp-cst-date-conc cst)))
Theorem:
(defthm smtp-cst-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-date-conc cst) (smtp-cst-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-msg-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "msg-id"))) (let ((__function__ 'smtp-cst-msg-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-msg-id-conc (b* ((cstss (smtp-cst-msg-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-msg-id-conc-match (implies (smtp-cst-matchp cst "msg-id") (b* ((cstss (smtp-cst-msg-id-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-msg-id-conc-of-tree-fix-cst (equal (smtp-cst-msg-id-conc (tree-fix cst)) (smtp-cst-msg-id-conc cst)))
Theorem:
(defthm smtp-cst-msg-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-msg-id-conc cst) (smtp-cst-msg-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-left-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-left-conc1 (b* ((cstss (smtp-cst-id-left-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)) (b* ((cstss (smtp-cst-id-left-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-of-tree-fix-cst (equal (smtp-cst-id-left-conc1 (tree-fix cst)) (smtp-cst-id-left-conc1 cst)))
Theorem:
(defthm smtp-cst-id-left-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc1 cst) (smtp-cst-id-left-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-left-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-left-conc2 (b* ((cstss (smtp-cst-id-left-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)) (b* ((cstss (smtp-cst-id-left-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-of-tree-fix-cst (equal (smtp-cst-id-left-conc2 (tree-fix cst)) (smtp-cst-id-left-conc2 cst)))
Theorem:
(defthm smtp-cst-id-left-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc2 cst) (smtp-cst-id-left-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dot-atom-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dot-atom-text"))) (let ((__function__ 'smtp-cst-dot-atom-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-dot-atom-text-conc (b* ((cstss (smtp-cst-dot-atom-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-atom-text-conc-match (implies (smtp-cst-matchp cst "dot-atom-text") (b* ((cstss (smtp-cst-dot-atom-text-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*atext *( \".\" 1*atext )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-atom-text-conc-of-tree-fix-cst (equal (smtp-cst-dot-atom-text-conc (tree-fix cst)) (smtp-cst-dot-atom-text-conc cst)))
Theorem:
(defthm smtp-cst-dot-atom-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dot-atom-text-conc cst) (smtp-cst-dot-atom-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-right-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-right-conc1 (b* ((cstss (smtp-cst-id-right-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)) (b* ((cstss (smtp-cst-id-right-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-of-tree-fix-cst (equal (smtp-cst-id-right-conc1 (tree-fix cst)) (smtp-cst-id-right-conc1 cst)))
Theorem:
(defthm smtp-cst-id-right-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc1 cst) (smtp-cst-id-right-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-right-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-right-conc2 (b* ((cstss (smtp-cst-id-right-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)) (b* ((cstss (smtp-cst-id-right-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-of-tree-fix-cst (equal (smtp-cst-id-right-conc2 (tree-fix cst)) (smtp-cst-id-right-conc2 cst)))
Theorem:
(defthm smtp-cst-id-right-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc2 cst) (smtp-cst-id-right-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)))) (let ((__function__ 'smtp-cst-id-right-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-id-right-conc3 (b* ((cstss (smtp-cst-id-right-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)) (b* ((cstss (smtp-cst-id-right-conc3 cst))) (smtp-cst-list-list-conc-matchp cstss "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-of-tree-fix-cst (equal (smtp-cst-id-right-conc3 (tree-fix cst)) (smtp-cst-id-right-conc3 cst)))
Theorem:
(defthm smtp-cst-id-right-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc3 cst) (smtp-cst-id-right-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-no-fold-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "no-fold-literal"))) (let ((__function__ 'smtp-cst-no-fold-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-no-fold-literal-conc (b* ((cstss (smtp-cst-no-fold-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-no-fold-literal-conc-match (implies (smtp-cst-matchp cst "no-fold-literal") (b* ((cstss (smtp-cst-no-fold-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-no-fold-literal-conc-of-tree-fix-cst (equal (smtp-cst-no-fold-literal-conc (tree-fix cst)) (smtp-cst-no-fold-literal-conc cst)))
Theorem:
(defthm smtp-cst-no-fold-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-no-fold-literal-conc cst) (smtp-cst-no-fold-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-ctext-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext"))) (let ((__function__ 'smtp-cst-obs-ctext-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-ctext-conc (b* ((cstss (smtp-cst-obs-ctext-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-match (implies (smtp-cst-matchp cst "obs-ctext") (b* ((cstss (smtp-cst-obs-ctext-conc cst))) (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-of-tree-fix-cst (equal (smtp-cst-obs-ctext-conc (tree-fix cst)) (smtp-cst-obs-ctext-conc cst)))
Theorem:
(defthm smtp-cst-obs-ctext-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-ctext-conc cst) (smtp-cst-obs-ctext-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-day-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-day"))) (let ((__function__ 'smtp-cst-obs-day-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-day-conc (b* ((cstss (smtp-cst-obs-day-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-day-conc-match (implies (smtp-cst-matchp cst "obs-day") (b* ((cstss (smtp-cst-obs-day-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 1*2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-day-conc-of-tree-fix-cst (equal (smtp-cst-obs-day-conc (tree-fix cst)) (smtp-cst-obs-day-conc cst)))
Theorem:
(defthm smtp-cst-obs-day-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-day-conc cst) (smtp-cst-obs-day-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-day-of-week-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-day-of-week"))) (let ((__function__ 'smtp-cst-obs-day-of-week-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-day-of-week-conc (b* ((cstss (smtp-cst-obs-day-of-week-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-day-of-week-conc-match (implies (smtp-cst-matchp cst "obs-day-of-week") (b* ((cstss (smtp-cst-obs-day-of-week-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] day-name [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-day-of-week-conc-of-tree-fix-cst (equal (smtp-cst-obs-day-of-week-conc (tree-fix cst)) (smtp-cst-obs-day-of-week-conc cst)))
Theorem:
(defthm smtp-cst-obs-day-of-week-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-day-of-week-conc cst) (smtp-cst-obs-day-of-week-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'smtp-cst-obs-dtext-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-dtext-conc1 (b* ((cstss (smtp-cst-obs-dtext-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)) (b* ((cstss (smtp-cst-obs-dtext-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc1 (tree-fix cst)) (smtp-cst-obs-dtext-conc1 cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc1 cst) (smtp-cst-obs-dtext-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'smtp-cst-obs-dtext-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-dtext-conc2 (b* ((cstss (smtp-cst-obs-dtext-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)) (b* ((cstss (smtp-cst-obs-dtext-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc2 (tree-fix cst)) (smtp-cst-obs-dtext-conc2 cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc2 cst) (smtp-cst-obs-dtext-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-fws-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-fws"))) (let ((__function__ 'smtp-cst-obs-fws-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-fws-conc (b* ((cstss (smtp-cst-obs-fws-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-fws-conc-match (implies (smtp-cst-matchp cst "obs-fws") (b* ((cstss (smtp-cst-obs-fws-conc cst))) (smtp-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-fws-conc-of-tree-fix-cst (equal (smtp-cst-obs-fws-conc (tree-fix cst)) (smtp-cst-obs-fws-conc cst)))
Theorem:
(defthm smtp-cst-obs-fws-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-fws-conc cst) (smtp-cst-obs-fws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-left-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left"))) (let ((__function__ 'smtp-cst-obs-id-left-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-id-left-conc (b* ((cstss (smtp-cst-obs-id-left-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-match (implies (smtp-cst-matchp cst "obs-id-left") (b* ((cstss (smtp-cst-obs-id-left-conc cst))) (smtp-cst-list-list-conc-matchp cstss "imf-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-of-tree-fix-cst (equal (smtp-cst-obs-id-left-conc (tree-fix cst)) (smtp-cst-obs-id-left-conc cst)))
Theorem:
(defthm smtp-cst-obs-id-left-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-left-conc cst) (smtp-cst-obs-id-left-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-local-part-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc1 (b* ((cstss (smtp-cst-imf-local-part-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)) (b* ((cstss (smtp-cst-imf-local-part-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc1 (tree-fix cst)) (smtp-cst-imf-local-part-conc1 cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc1 cst) (smtp-cst-imf-local-part-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-local-part-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc2 (b* ((cstss (smtp-cst-imf-local-part-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)) (b* ((cstss (smtp-cst-imf-local-part-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc2 (tree-fix cst)) (smtp-cst-imf-local-part-conc2 cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc2 cst) (smtp-cst-imf-local-part-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-local-part-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc3 (b* ((cstss (smtp-cst-imf-local-part-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)) (b* ((cstss (smtp-cst-imf-local-part-conc3 cst))) (smtp-cst-list-list-conc-matchp cstss "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc3 (tree-fix cst)) (smtp-cst-imf-local-part-conc3 cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc3 cst) (smtp-cst-imf-local-part-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dot-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dot-atom"))) (let ((__function__ 'smtp-cst-dot-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-dot-atom-conc (b* ((cstss (smtp-cst-dot-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-atom-conc-match (implies (smtp-cst-matchp cst "dot-atom") (b* ((cstss (smtp-cst-dot-atom-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] dot-atom-text [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dot-atom-conc-of-tree-fix-cst (equal (smtp-cst-dot-atom-conc (tree-fix cst)) (smtp-cst-dot-atom-conc cst)))
Theorem:
(defthm smtp-cst-dot-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dot-atom-conc cst) (smtp-cst-dot-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-quoted-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "imf-quoted-string"))) (let ((__function__ 'smtp-cst-imf-quoted-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-quoted-string-conc (b* ((cstss (smtp-cst-imf-quoted-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-quoted-string-conc-match (implies (smtp-cst-matchp cst "imf-quoted-string") (b* ((cstss (smtp-cst-imf-quoted-string-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-quoted-string-conc-of-tree-fix-cst (equal (smtp-cst-imf-quoted-string-conc (tree-fix cst)) (smtp-cst-imf-quoted-string-conc cst)))
Theorem:
(defthm smtp-cst-imf-quoted-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-quoted-string-conc cst) (smtp-cst-imf-quoted-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-right-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right"))) (let ((__function__ 'smtp-cst-obs-id-right-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-id-right-conc (b* ((cstss (smtp-cst-obs-id-right-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-match (implies (smtp-cst-matchp cst "obs-id-right") (b* ((cstss (smtp-cst-obs-id-right-conc cst))) (smtp-cst-list-list-conc-matchp cstss "imf-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-of-tree-fix-cst (equal (smtp-cst-obs-id-right-conc (tree-fix cst)) (smtp-cst-obs-id-right-conc cst)))
Theorem:
(defthm smtp-cst-obs-id-right-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-right-conc cst) (smtp-cst-obs-id-right-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-domain-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-domain-conc1 (b* ((cstss (smtp-cst-imf-domain-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)) (b* ((cstss (smtp-cst-imf-domain-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc1 (tree-fix cst)) (smtp-cst-imf-domain-conc1 cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc1 cst) (smtp-cst-imf-domain-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-domain-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-domain-conc2 (b* ((cstss (smtp-cst-imf-domain-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)) (b* ((cstss (smtp-cst-imf-domain-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc2 (tree-fix cst)) (smtp-cst-imf-domain-conc2 cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc2 cst) (smtp-cst-imf-domain-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-domain-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-domain-conc3 (b* ((cstss (smtp-cst-imf-domain-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)) (b* ((cstss (smtp-cst-imf-domain-conc3 cst))) (smtp-cst-list-list-conc-matchp cstss "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc3 (tree-fix cst)) (smtp-cst-imf-domain-conc3 cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc3 cst) (smtp-cst-imf-domain-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-domain-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "domain-literal"))) (let ((__function__ 'smtp-cst-domain-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-domain-literal-conc (b* ((cstss (smtp-cst-domain-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-domain-literal-conc-match (implies (smtp-cst-matchp cst "domain-literal") (b* ((cstss (smtp-cst-domain-literal-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-domain-literal-conc-of-tree-fix-cst (equal (smtp-cst-domain-literal-conc (tree-fix cst)) (smtp-cst-domain-literal-conc cst)))
Theorem:
(defthm smtp-cst-domain-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-domain-literal-conc cst) (smtp-cst-domain-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-domain"))) (let ((__function__ 'smtp-cst-obs-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-domain-conc (b* ((cstss (smtp-cst-obs-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-domain-conc-match (implies (smtp-cst-matchp cst "obs-domain") (b* ((cstss (smtp-cst-obs-domain-conc cst))) (smtp-cst-list-list-conc-matchp cstss "imf-atom *( \".\" imf-atom )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-domain-conc-of-tree-fix-cst (equal (smtp-cst-obs-domain-conc (tree-fix cst)) (smtp-cst-obs-domain-conc cst)))
Theorem:
(defthm smtp-cst-obs-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-domain-conc cst) (smtp-cst-obs-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "imf-atom"))) (let ((__function__ 'smtp-cst-imf-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-imf-atom-conc (b* ((cstss (smtp-cst-imf-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-atom-conc-match (implies (smtp-cst-matchp cst "imf-atom") (b* ((cstss (smtp-cst-imf-atom-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 1*atext [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-atom-conc-of-tree-fix-cst (equal (smtp-cst-imf-atom-conc (tree-fix cst)) (smtp-cst-imf-atom-conc cst)))
Theorem:
(defthm smtp-cst-imf-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-atom-conc cst) (smtp-cst-imf-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-local-part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-local-part"))) (let ((__function__ 'smtp-cst-obs-local-part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-local-part-conc (b* ((cstss (smtp-cst-obs-local-part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-local-part-conc-match (implies (smtp-cst-matchp cst "obs-local-part") (b* ((cstss (smtp-cst-obs-local-part-conc cst))) (smtp-cst-list-list-conc-matchp cstss "word *( \".\" word )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-local-part-conc-of-tree-fix-cst (equal (smtp-cst-obs-local-part-conc (tree-fix cst)) (smtp-cst-obs-local-part-conc cst)))
Theorem:
(defthm smtp-cst-obs-local-part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-local-part-conc cst) (smtp-cst-obs-local-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontent-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-qcontent-conc1 (b* ((cstss (smtp-cst-qcontent-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)) (b* ((cstss (smtp-cst-qcontent-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-of-tree-fix-cst (equal (smtp-cst-qcontent-conc1 (tree-fix cst)) (smtp-cst-qcontent-conc1 cst)))
Theorem:
(defthm smtp-cst-qcontent-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc1 cst) (smtp-cst-qcontent-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontent-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-qcontent-conc2 (b* ((cstss (smtp-cst-qcontent-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)) (b* ((cstss (smtp-cst-qcontent-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-of-tree-fix-cst (equal (smtp-cst-qcontent-conc2 (tree-fix cst)) (smtp-cst-qcontent-conc2 cst)))
Theorem:
(defthm smtp-cst-qcontent-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc2 cst) (smtp-cst-qcontent-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-qtext-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext"))) (let ((__function__ 'smtp-cst-obs-qtext-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-qtext-conc (b* ((cstss (smtp-cst-obs-qtext-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-match (implies (smtp-cst-matchp cst "obs-qtext") (b* ((cstss (smtp-cst-obs-qtext-conc cst))) (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-of-tree-fix-cst (equal (smtp-cst-obs-qtext-conc (tree-fix cst)) (smtp-cst-obs-qtext-conc cst)))
Theorem:
(defthm smtp-cst-obs-qtext-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-qtext-conc cst) (smtp-cst-obs-qtext-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-qp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-qp"))) (let ((__function__ 'smtp-cst-obs-qp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-qp-conc (b* ((cstss (smtp-cst-obs-qp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qp-conc-match (implies (smtp-cst-matchp cst "obs-qp") (b* ((cstss (smtp-cst-obs-qp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qp-conc-of-tree-fix-cst (equal (smtp-cst-obs-qp-conc (tree-fix cst)) (smtp-cst-obs-qp-conc cst)))
Theorem:
(defthm smtp-cst-obs-qp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-qp-conc cst) (smtp-cst-obs-qp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "time"))) (let ((__function__ 'smtp-cst-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-time-conc (b* ((cstss (smtp-cst-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-conc-match (implies (smtp-cst-matchp cst "time") (b* ((cstss (smtp-cst-time-conc cst))) (smtp-cst-list-list-conc-matchp cstss "time-of-day zone"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-conc-of-tree-fix-cst (equal (smtp-cst-time-conc (tree-fix cst)) (smtp-cst-time-conc cst)))
Theorem:
(defthm smtp-cst-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-time-conc cst) (smtp-cst-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-time-of-day-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "time-of-day"))) (let ((__function__ 'smtp-cst-time-of-day-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-time-of-day-conc (b* ((cstss (smtp-cst-time-of-day-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-of-day-conc-match (implies (smtp-cst-matchp cst "time-of-day") (b* ((cstss (smtp-cst-time-of-day-conc cst))) (smtp-cst-list-list-conc-matchp cstss "hour \":\" minute [ \":\" second ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-time-of-day-conc-of-tree-fix-cst (equal (smtp-cst-time-of-day-conc (tree-fix cst)) (smtp-cst-time-of-day-conc cst)))
Theorem:
(defthm smtp-cst-time-of-day-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-time-of-day-conc cst) (smtp-cst-time-of-day-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-hour-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-hour"))) (let ((__function__ 'smtp-cst-obs-hour-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-hour-conc (b* ((cstss (smtp-cst-obs-hour-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-hour-conc-match (implies (smtp-cst-matchp cst "obs-hour") (b* ((cstss (smtp-cst-obs-hour-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-hour-conc-of-tree-fix-cst (equal (smtp-cst-obs-hour-conc (tree-fix cst)) (smtp-cst-obs-hour-conc cst)))
Theorem:
(defthm smtp-cst-obs-hour-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-hour-conc cst) (smtp-cst-obs-hour-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-minute-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-minute"))) (let ((__function__ 'smtp-cst-obs-minute-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-minute-conc (b* ((cstss (smtp-cst-obs-minute-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-minute-conc-match (implies (smtp-cst-matchp cst "obs-minute") (b* ((cstss (smtp-cst-obs-minute-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-minute-conc-of-tree-fix-cst (equal (smtp-cst-obs-minute-conc (tree-fix cst)) (smtp-cst-obs-minute-conc cst)))
Theorem:
(defthm smtp-cst-obs-minute-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-minute-conc cst) (smtp-cst-obs-minute-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-second-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-second"))) (let ((__function__ 'smtp-cst-obs-second-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-second-conc (b* ((cstss (smtp-cst-obs-second-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-second-conc-match (implies (smtp-cst-matchp cst "obs-second") (b* ((cstss (smtp-cst-obs-second-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-second-conc-of-tree-fix-cst (equal (smtp-cst-obs-second-conc (tree-fix cst)) (smtp-cst-obs-second-conc cst)))
Theorem:
(defthm smtp-cst-obs-second-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-second-conc cst) (smtp-cst-obs-second-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)))) (let ((__function__ 'smtp-cst-word-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-word-conc1 (b* ((cstss (smtp-cst-word-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)) (b* ((cstss (smtp-cst-word-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "imf-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-of-tree-fix-cst (equal (smtp-cst-word-conc1 (tree-fix cst)) (smtp-cst-word-conc1 cst)))
Theorem:
(defthm smtp-cst-word-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc1 cst) (smtp-cst-word-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)))) (let ((__function__ 'smtp-cst-word-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-word-conc2 (b* ((cstss (smtp-cst-word-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)) (b* ((cstss (smtp-cst-word-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-of-tree-fix-cst (equal (smtp-cst-word-conc2 (tree-fix cst)) (smtp-cst-word-conc2 cst)))
Theorem:
(defthm smtp-cst-word-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc2 cst) (smtp-cst-word-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-year-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-year"))) (let ((__function__ 'smtp-cst-obs-year-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-obs-year-conc (b* ((cstss (smtp-cst-obs-year-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-year-conc-match (implies (smtp-cst-matchp cst "obs-year") (b* ((cstss (smtp-cst-obs-year-conc cst))) (smtp-cst-list-list-conc-matchp cstss "[ cfws ] 2*digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-year-conc-of-tree-fix-cst (equal (smtp-cst-obs-year-conc (tree-fix cst)) (smtp-cst-obs-year-conc cst)))
Theorem:
(defthm smtp-cst-obs-year-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-year-conc cst) (smtp-cst-obs-year-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-cr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "cr"))) (let ((__function__ 'smtp-cst-cr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-cr-conc (b* ((cstss (smtp-cst-cr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-match (implies (smtp-cst-matchp cst "cr") (b* ((cstss (smtp-cst-cr-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-of-tree-fix-cst (equal (smtp-cst-cr-conc (tree-fix cst)) (smtp-cst-cr-conc cst)))
Theorem:
(defthm smtp-cst-cr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-cr-conc cst) (smtp-cst-cr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-crlf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "crlf"))) (let ((__function__ 'smtp-cst-crlf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-crlf-conc (b* ((cstss (smtp-cst-crlf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-crlf-conc-match (implies (smtp-cst-matchp cst "crlf") (b* ((cstss (smtp-cst-crlf-conc cst))) (smtp-cst-list-list-conc-matchp cstss "cr lf"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-crlf-conc-of-tree-fix-cst (equal (smtp-cst-crlf-conc (tree-fix cst)) (smtp-cst-crlf-conc cst)))
Theorem:
(defthm smtp-cst-crlf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-crlf-conc cst) (smtp-cst-crlf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-digit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "digit"))) (let ((__function__ 'smtp-cst-digit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-digit-conc (b* ((cstss (smtp-cst-digit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-match (implies (smtp-cst-matchp cst "digit") (b* ((cstss (smtp-cst-digit-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-of-tree-fix-cst (equal (smtp-cst-digit-conc (tree-fix cst)) (smtp-cst-digit-conc cst)))
Theorem:
(defthm smtp-cst-digit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-digit-conc cst) (smtp-cst-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dquote-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dquote"))) (let ((__function__ 'smtp-cst-dquote-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-dquote-conc (b* ((cstss (smtp-cst-dquote-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-match (implies (smtp-cst-matchp cst "dquote") (b* ((cstss (smtp-cst-dquote-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-of-tree-fix-cst (equal (smtp-cst-dquote-conc (tree-fix cst)) (smtp-cst-dquote-conc cst)))
Theorem:
(defthm smtp-cst-dquote-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dquote-conc cst) (smtp-cst-dquote-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-lf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "lf"))) (let ((__function__ 'smtp-cst-lf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-lf-conc (b* ((cstss (smtp-cst-lf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-match (implies (smtp-cst-matchp cst "lf") (b* ((cstss (smtp-cst-lf-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-of-tree-fix-cst (equal (smtp-cst-lf-conc (tree-fix cst)) (smtp-cst-lf-conc cst)))
Theorem:
(defthm smtp-cst-lf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-lf-conc cst) (smtp-cst-lf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-sp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "sp"))) (let ((__function__ 'smtp-cst-sp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-sp-conc (b* ((cstss (smtp-cst-sp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-match (implies (smtp-cst-matchp cst "sp") (b* ((cstss (smtp-cst-sp-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-of-tree-fix-cst (equal (smtp-cst-sp-conc (tree-fix cst)) (smtp-cst-sp-conc cst)))
Theorem:
(defthm smtp-cst-sp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-sp-conc cst) (smtp-cst-sp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-vchar-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "vchar"))) (let ((__function__ 'smtp-cst-vchar-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-vchar-conc (b* ((cstss (smtp-cst-vchar-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-match (implies (smtp-cst-matchp cst "vchar") (b* ((cstss (smtp-cst-vchar-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-of-tree-fix-cst (equal (smtp-cst-vchar-conc (tree-fix cst)) (smtp-cst-vchar-conc cst)))
Theorem:
(defthm smtp-cst-vchar-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-vchar-conc cst) (smtp-cst-vchar-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-wsp-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-wsp-conc1 (b* ((cstss (smtp-cst-wsp-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)) (b* ((cstss (smtp-cst-wsp-conc1 cst))) (smtp-cst-list-list-conc-matchp cstss "sp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-of-tree-fix-cst (equal (smtp-cst-wsp-conc1 (tree-fix cst)) (smtp-cst-wsp-conc1 cst)))
Theorem:
(defthm smtp-cst-wsp-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc1 cst) (smtp-cst-wsp-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-wsp-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-wsp-conc2 (b* ((cstss (smtp-cst-wsp-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)) (b* ((cstss (smtp-cst-wsp-conc2 cst))) (smtp-cst-list-list-conc-matchp cstss "htab"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-of-tree-fix-cst (equal (smtp-cst-wsp-conc2 (tree-fix cst)) (smtp-cst-wsp-conc2 cst)))
Theorem:
(defthm smtp-cst-wsp-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc2 cst) (smtp-cst-wsp-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-htab-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "htab"))) (let ((__function__ 'smtp-cst-htab-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-smtp-cst-htab-conc (b* ((cstss (smtp-cst-htab-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-match (implies (smtp-cst-matchp cst "htab") (b* ((cstss (smtp-cst-htab-conc cst))) (smtp-cst-list-list-conc-matchp cstss "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-of-tree-fix-cst (equal (smtp-cst-htab-conc (tree-fix cst)) (smtp-cst-htab-conc cst)))
Theorem:
(defthm smtp-cst-htab-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-htab-conc cst) (smtp-cst-htab-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-forward-path-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "forward-path"))) (let ((__function__ 'smtp-cst-forward-path-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-forward-path-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-forward-path-conc-rep (b* ((csts (smtp-cst-forward-path-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-rep-match (implies (smtp-cst-matchp cst "forward-path") (b* ((csts (smtp-cst-forward-path-conc-rep cst))) (smtp-cst-list-rep-matchp csts "path"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-rep-of-tree-fix-cst (equal (smtp-cst-forward-path-conc-rep (tree-fix cst)) (smtp-cst-forward-path-conc-rep cst)))
Theorem:
(defthm smtp-cst-forward-path-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-forward-path-conc-rep cst) (smtp-cst-forward-path-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-keyword-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "keyword"))) (let ((__function__ 'smtp-cst-keyword-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-keyword-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-keyword-conc-rep (b* ((csts (smtp-cst-keyword-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-rep-match (implies (smtp-cst-matchp cst "keyword") (b* ((csts (smtp-cst-keyword-conc-rep cst))) (smtp-cst-list-rep-matchp csts "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-rep-of-tree-fix-cst (equal (smtp-cst-keyword-conc-rep (tree-fix cst)) (smtp-cst-keyword-conc-rep cst)))
Theorem:
(defthm smtp-cst-keyword-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-keyword-conc-rep cst) (smtp-cst-keyword-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-argument-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "argument"))) (let ((__function__ 'smtp-cst-argument-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-argument-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-argument-conc-rep (b* ((csts (smtp-cst-argument-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-rep-match (implies (smtp-cst-matchp cst "argument") (b* ((csts (smtp-cst-argument-conc-rep cst))) (smtp-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-rep-of-tree-fix-cst (equal (smtp-cst-argument-conc-rep (tree-fix cst)) (smtp-cst-argument-conc-rep cst)))
Theorem:
(defthm smtp-cst-argument-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-argument-conc-rep cst) (smtp-cst-argument-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)))) (let ((__function__ 'smtp-cst-let-dig-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-let-dig-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-let-dig-conc1-rep (b* ((csts (smtp-cst-let-dig-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)) (b* ((csts (smtp-cst-let-dig-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "alpha"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-of-tree-fix-cst (equal (smtp-cst-let-dig-conc1-rep (tree-fix cst)) (smtp-cst-let-dig-conc1-rep cst)))
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc1-rep cst) (smtp-cst-let-dig-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)))) (let ((__function__ 'smtp-cst-let-dig-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-let-dig-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-let-dig-conc2-rep (b* ((csts (smtp-cst-let-dig-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)) (b* ((csts (smtp-cst-let-dig-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "digit"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-of-tree-fix-cst (equal (smtp-cst-let-dig-conc2-rep (tree-fix cst)) (smtp-cst-let-dig-conc2-rep cst)))
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc2-rep cst) (smtp-cst-let-dig-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-local-part-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-local-part-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-local-part-conc1-rep (b* ((csts (smtp-cst-local-part-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-rep-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)) (b* ((csts (smtp-cst-local-part-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "dot-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-rep-of-tree-fix-cst (equal (smtp-cst-local-part-conc1-rep (tree-fix cst)) (smtp-cst-local-part-conc1-rep cst)))
Theorem:
(defthm smtp-cst-local-part-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc1-rep cst) (smtp-cst-local-part-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-local-part-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-local-part-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-local-part-conc2-rep (b* ((csts (smtp-cst-local-part-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-rep-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)) (b* ((csts (smtp-cst-local-part-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-rep-of-tree-fix-cst (equal (smtp-cst-local-part-conc2-rep (tree-fix cst)) (smtp-cst-local-part-conc2-rep cst)))
Theorem:
(defthm smtp-cst-local-part-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc2-rep cst) (smtp-cst-local-part-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-qcontentsmtp-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-qcontentsmtp-conc1-rep (b* ((csts (smtp-cst-qcontentsmtp-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)) (b* ((csts (smtp-cst-qcontentsmtp-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "qtextsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc1-rep (tree-fix cst)) (smtp-cst-qcontentsmtp-conc1-rep cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc1-rep cst) (smtp-cst-qcontentsmtp-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-qcontentsmtp-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-qcontentsmtp-conc2-rep (b* ((csts (smtp-cst-qcontentsmtp-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)) (b* ((csts (smtp-cst-qcontentsmtp-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-pairsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc2-rep (tree-fix cst)) (smtp-cst-qcontentsmtp-conc2-rep cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc2-rep cst) (smtp-cst-qcontentsmtp-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)))) (let ((__function__ 'smtp-cst-string-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-string-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-string-conc1-rep (b* ((csts (smtp-cst-string-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-rep-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)) (b* ((csts (smtp-cst-string-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-rep-of-tree-fix-cst (equal (smtp-cst-string-conc1-rep (tree-fix cst)) (smtp-cst-string-conc1-rep cst)))
Theorem:
(defthm smtp-cst-string-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc1-rep cst) (smtp-cst-string-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)))) (let ((__function__ 'smtp-cst-string-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-string-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-string-conc2-rep (b* ((csts (smtp-cst-string-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-rep-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)) (b* ((csts (smtp-cst-string-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-rep-of-tree-fix-cst (equal (smtp-cst-string-conc2-rep (tree-fix cst)) (smtp-cst-string-conc2-rep cst)))
Theorem:
(defthm smtp-cst-string-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc2-rep cst) (smtp-cst-string-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-standardized-tag-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag"))) (let ((__function__ 'smtp-cst-standardized-tag-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-standardized-tag-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-standardized-tag-conc-rep (b* ((csts (smtp-cst-standardized-tag-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-match (implies (smtp-cst-matchp cst "standardized-tag") (b* ((csts (smtp-cst-standardized-tag-conc-rep cst))) (smtp-cst-list-rep-matchp csts "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-of-tree-fix-cst (equal (smtp-cst-standardized-tag-conc-rep (tree-fix cst)) (smtp-cst-standardized-tag-conc-rep cst)))
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-standardized-tag-conc-rep cst) (smtp-cst-standardized-tag-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ipv6-addr-conc1-rep (b* ((csts (smtp-cst-ipv6-addr-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)) (b* ((csts (smtp-cst-ipv6-addr-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "ipv6-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc1-rep (tree-fix cst)) (smtp-cst-ipv6-addr-conc1-rep cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc1-rep cst) (smtp-cst-ipv6-addr-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ipv6-addr-conc2-rep (b* ((csts (smtp-cst-ipv6-addr-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)) (b* ((csts (smtp-cst-ipv6-addr-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "ipv6-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc2-rep (tree-fix cst)) (smtp-cst-ipv6-addr-conc2-rep cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc2-rep cst) (smtp-cst-ipv6-addr-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc3 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ipv6-addr-conc3-rep (b* ((csts (smtp-cst-ipv6-addr-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)) (b* ((csts (smtp-cst-ipv6-addr-conc3-rep cst))) (smtp-cst-list-rep-matchp csts "ipv6v4-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc3-rep (tree-fix cst)) (smtp-cst-ipv6-addr-conc3-rep cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc3-rep cst) (smtp-cst-ipv6-addr-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc4 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ipv6-addr-conc4-rep (b* ((csts (smtp-cst-ipv6-addr-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)) (b* ((csts (smtp-cst-ipv6-addr-conc4-rep cst))) (smtp-cst-list-rep-matchp csts "ipv6v4-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc4-rep (tree-fix cst)) (smtp-cst-ipv6-addr-conc4-rep cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc4-rep cst) (smtp-cst-ipv6-addr-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-addtl-link-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "addtl-link"))) (let ((__function__ 'smtp-cst-addtl-link-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-addtl-link-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-addtl-link-conc-rep (b* ((csts (smtp-cst-addtl-link-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-match (implies (smtp-cst-matchp cst "addtl-link") (b* ((csts (smtp-cst-addtl-link-conc-rep cst))) (smtp-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-of-tree-fix-cst (equal (smtp-cst-addtl-link-conc-rep (tree-fix cst)) (smtp-cst-addtl-link-conc-rep cst)))
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-addtl-link-conc-rep cst) (smtp-cst-addtl-link-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-attdl-protocol-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol"))) (let ((__function__ 'smtp-cst-attdl-protocol-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-attdl-protocol-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-attdl-protocol-conc-rep (b* ((csts (smtp-cst-attdl-protocol-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-match (implies (smtp-cst-matchp cst "attdl-protocol") (b* ((csts (smtp-cst-attdl-protocol-conc-rep cst))) (smtp-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-of-tree-fix-cst (equal (smtp-cst-attdl-protocol-conc-rep (tree-fix cst)) (smtp-cst-attdl-protocol-conc-rep cst)))
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-attdl-protocol-conc-rep cst) (smtp-cst-attdl-protocol-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ccontent-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ccontent-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ccontent-conc1-rep (b* ((csts (smtp-cst-ccontent-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)) (b* ((csts (smtp-cst-ccontent-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-of-tree-fix-cst (equal (smtp-cst-ccontent-conc1-rep (tree-fix cst)) (smtp-cst-ccontent-conc1-rep cst)))
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc1-rep cst) (smtp-cst-ccontent-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ccontent-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ccontent-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ccontent-conc2-rep (b* ((csts (smtp-cst-ccontent-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)) (b* ((csts (smtp-cst-ccontent-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-of-tree-fix-cst (equal (smtp-cst-ccontent-conc2-rep (tree-fix cst)) (smtp-cst-ccontent-conc2-rep cst)))
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc2-rep cst) (smtp-cst-ccontent-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ccontent-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-ccontent-conc3 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-ccontent-conc3-rep (b* ((csts (smtp-cst-ccontent-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)) (b* ((csts (smtp-cst-ccontent-conc3-rep cst))) (smtp-cst-list-rep-matchp csts "comment"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-of-tree-fix-cst (equal (smtp-cst-ccontent-conc3-rep (tree-fix cst)) (smtp-cst-ccontent-conc3-rep cst)))
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc3-rep cst) (smtp-cst-ccontent-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-left-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-id-left-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-id-left-conc1-rep (b* ((csts (smtp-cst-id-left-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-rep-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)) (b* ((csts (smtp-cst-id-left-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-rep-of-tree-fix-cst (equal (smtp-cst-id-left-conc1-rep (tree-fix cst)) (smtp-cst-id-left-conc1-rep cst)))
Theorem:
(defthm smtp-cst-id-left-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc1-rep cst) (smtp-cst-id-left-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-left-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-id-left-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-id-left-conc2-rep (b* ((csts (smtp-cst-id-left-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-rep-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)) (b* ((csts (smtp-cst-id-left-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-rep-of-tree-fix-cst (equal (smtp-cst-id-left-conc2-rep (tree-fix cst)) (smtp-cst-id-left-conc2-rep cst)))
Theorem:
(defthm smtp-cst-id-left-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc2-rep cst) (smtp-cst-id-left-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-right-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-id-right-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-id-right-conc1-rep (b* ((csts (smtp-cst-id-right-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-rep-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)) (b* ((csts (smtp-cst-id-right-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-rep-of-tree-fix-cst (equal (smtp-cst-id-right-conc1-rep (tree-fix cst)) (smtp-cst-id-right-conc1-rep cst)))
Theorem:
(defthm smtp-cst-id-right-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc1-rep cst) (smtp-cst-id-right-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-right-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-id-right-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-id-right-conc2-rep (b* ((csts (smtp-cst-id-right-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-rep-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)) (b* ((csts (smtp-cst-id-right-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-rep-of-tree-fix-cst (equal (smtp-cst-id-right-conc2-rep (tree-fix cst)) (smtp-cst-id-right-conc2-rep cst)))
Theorem:
(defthm smtp-cst-id-right-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc2-rep cst) (smtp-cst-id-right-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)))) (let ((__function__ 'smtp-cst-id-right-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-id-right-conc3 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-id-right-conc3-rep (b* ((csts (smtp-cst-id-right-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-rep-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)) (b* ((csts (smtp-cst-id-right-conc3-rep cst))) (smtp-cst-list-rep-matchp csts "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-rep-of-tree-fix-cst (equal (smtp-cst-id-right-conc3-rep (tree-fix cst)) (smtp-cst-id-right-conc3-rep cst)))
Theorem:
(defthm smtp-cst-id-right-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc3-rep cst) (smtp-cst-id-right-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-ctext-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext"))) (let ((__function__ 'smtp-cst-obs-ctext-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-ctext-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-ctext-conc-rep (b* ((csts (smtp-cst-obs-ctext-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-match (implies (smtp-cst-matchp cst "obs-ctext") (b* ((csts (smtp-cst-obs-ctext-conc-rep cst))) (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-of-tree-fix-cst (equal (smtp-cst-obs-ctext-conc-rep (tree-fix cst)) (smtp-cst-obs-ctext-conc-rep cst)))
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-ctext-conc-rep cst) (smtp-cst-obs-ctext-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'smtp-cst-obs-dtext-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-dtext-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-dtext-conc1-rep (b* ((csts (smtp-cst-obs-dtext-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)) (b* ((csts (smtp-cst-obs-dtext-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc1-rep (tree-fix cst)) (smtp-cst-obs-dtext-conc1-rep cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc1-rep cst) (smtp-cst-obs-dtext-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'smtp-cst-obs-dtext-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-dtext-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-dtext-conc2-rep (b* ((csts (smtp-cst-obs-dtext-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)) (b* ((csts (smtp-cst-obs-dtext-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc2-rep (tree-fix cst)) (smtp-cst-obs-dtext-conc2-rep cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc2-rep cst) (smtp-cst-obs-dtext-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-left-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left"))) (let ((__function__ 'smtp-cst-obs-id-left-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-id-left-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-id-left-conc-rep (b* ((csts (smtp-cst-obs-id-left-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-match (implies (smtp-cst-matchp cst "obs-id-left") (b* ((csts (smtp-cst-obs-id-left-conc-rep cst))) (smtp-cst-list-rep-matchp csts "imf-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-of-tree-fix-cst (equal (smtp-cst-obs-id-left-conc-rep (tree-fix cst)) (smtp-cst-obs-id-left-conc-rep cst)))
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-left-conc-rep cst) (smtp-cst-obs-id-left-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-local-part-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-local-part-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-local-part-conc1-rep (b* ((csts (smtp-cst-imf-local-part-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)) (b* ((csts (smtp-cst-imf-local-part-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc1-rep (tree-fix cst)) (smtp-cst-imf-local-part-conc1-rep cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc1-rep cst) (smtp-cst-imf-local-part-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-local-part-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-local-part-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-local-part-conc2-rep (b* ((csts (smtp-cst-imf-local-part-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)) (b* ((csts (smtp-cst-imf-local-part-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc2-rep (tree-fix cst)) (smtp-cst-imf-local-part-conc2-rep cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc2-rep cst) (smtp-cst-imf-local-part-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-local-part-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-local-part-conc3 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-local-part-conc3-rep (b* ((csts (smtp-cst-imf-local-part-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)) (b* ((csts (smtp-cst-imf-local-part-conc3-rep cst))) (smtp-cst-list-rep-matchp csts "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc3-rep (tree-fix cst)) (smtp-cst-imf-local-part-conc3-rep cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc3-rep cst) (smtp-cst-imf-local-part-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-right-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right"))) (let ((__function__ 'smtp-cst-obs-id-right-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-id-right-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-id-right-conc-rep (b* ((csts (smtp-cst-obs-id-right-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-match (implies (smtp-cst-matchp cst "obs-id-right") (b* ((csts (smtp-cst-obs-id-right-conc-rep cst))) (smtp-cst-list-rep-matchp csts "imf-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-of-tree-fix-cst (equal (smtp-cst-obs-id-right-conc-rep (tree-fix cst)) (smtp-cst-obs-id-right-conc-rep cst)))
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-right-conc-rep cst) (smtp-cst-obs-id-right-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-domain-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-domain-conc1-rep (b* ((csts (smtp-cst-imf-domain-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)) (b* ((csts (smtp-cst-imf-domain-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc1-rep (tree-fix cst)) (smtp-cst-imf-domain-conc1-rep cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc1-rep cst) (smtp-cst-imf-domain-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-domain-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-domain-conc2-rep (b* ((csts (smtp-cst-imf-domain-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)) (b* ((csts (smtp-cst-imf-domain-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc2-rep (tree-fix cst)) (smtp-cst-imf-domain-conc2-rep cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc2-rep cst) (smtp-cst-imf-domain-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-domain-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc3 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-imf-domain-conc3-rep (b* ((csts (smtp-cst-imf-domain-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)) (b* ((csts (smtp-cst-imf-domain-conc3-rep cst))) (smtp-cst-list-rep-matchp csts "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc3-rep (tree-fix cst)) (smtp-cst-imf-domain-conc3-rep cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc3-rep cst) (smtp-cst-imf-domain-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontent-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-qcontent-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-qcontent-conc1-rep (b* ((csts (smtp-cst-qcontent-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)) (b* ((csts (smtp-cst-qcontent-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-of-tree-fix-cst (equal (smtp-cst-qcontent-conc1-rep (tree-fix cst)) (smtp-cst-qcontent-conc1-rep cst)))
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc1-rep cst) (smtp-cst-qcontent-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontent-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-qcontent-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-qcontent-conc2-rep (b* ((csts (smtp-cst-qcontent-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)) (b* ((csts (smtp-cst-qcontent-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-of-tree-fix-cst (equal (smtp-cst-qcontent-conc2-rep (tree-fix cst)) (smtp-cst-qcontent-conc2-rep cst)))
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc2-rep cst) (smtp-cst-qcontent-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-qtext-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext"))) (let ((__function__ 'smtp-cst-obs-qtext-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-obs-qtext-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-obs-qtext-conc-rep (b* ((csts (smtp-cst-obs-qtext-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-match (implies (smtp-cst-matchp cst "obs-qtext") (b* ((csts (smtp-cst-obs-qtext-conc-rep cst))) (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-of-tree-fix-cst (equal (smtp-cst-obs-qtext-conc-rep (tree-fix cst)) (smtp-cst-obs-qtext-conc-rep cst)))
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-qtext-conc-rep cst) (smtp-cst-obs-qtext-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)))) (let ((__function__ 'smtp-cst-word-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-word-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-word-conc1-rep (b* ((csts (smtp-cst-word-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-rep-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)) (b* ((csts (smtp-cst-word-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "imf-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-rep-of-tree-fix-cst (equal (smtp-cst-word-conc1-rep (tree-fix cst)) (smtp-cst-word-conc1-rep cst)))
Theorem:
(defthm smtp-cst-word-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc1-rep cst) (smtp-cst-word-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)))) (let ((__function__ 'smtp-cst-word-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-word-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-word-conc2-rep (b* ((csts (smtp-cst-word-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-rep-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)) (b* ((csts (smtp-cst-word-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-rep-of-tree-fix-cst (equal (smtp-cst-word-conc2-rep (tree-fix cst)) (smtp-cst-word-conc2-rep cst)))
Theorem:
(defthm smtp-cst-word-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc2-rep cst) (smtp-cst-word-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-cr-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "cr"))) (let ((__function__ 'smtp-cst-cr-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-cr-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-cr-conc-rep (b* ((csts (smtp-cst-cr-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-rep-match (implies (smtp-cst-matchp cst "cr") (b* ((csts (smtp-cst-cr-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-rep-of-tree-fix-cst (equal (smtp-cst-cr-conc-rep (tree-fix cst)) (smtp-cst-cr-conc-rep cst)))
Theorem:
(defthm smtp-cst-cr-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-cr-conc-rep cst) (smtp-cst-cr-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-digit-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "digit"))) (let ((__function__ 'smtp-cst-digit-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-digit-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-digit-conc-rep (b* ((csts (smtp-cst-digit-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-rep-match (implies (smtp-cst-matchp cst "digit") (b* ((csts (smtp-cst-digit-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-rep-of-tree-fix-cst (equal (smtp-cst-digit-conc-rep (tree-fix cst)) (smtp-cst-digit-conc-rep cst)))
Theorem:
(defthm smtp-cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-digit-conc-rep cst) (smtp-cst-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dquote-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dquote"))) (let ((__function__ 'smtp-cst-dquote-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-dquote-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-dquote-conc-rep (b* ((csts (smtp-cst-dquote-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-rep-match (implies (smtp-cst-matchp cst "dquote") (b* ((csts (smtp-cst-dquote-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-rep-of-tree-fix-cst (equal (smtp-cst-dquote-conc-rep (tree-fix cst)) (smtp-cst-dquote-conc-rep cst)))
Theorem:
(defthm smtp-cst-dquote-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dquote-conc-rep cst) (smtp-cst-dquote-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-lf-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "lf"))) (let ((__function__ 'smtp-cst-lf-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-lf-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-lf-conc-rep (b* ((csts (smtp-cst-lf-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-rep-match (implies (smtp-cst-matchp cst "lf") (b* ((csts (smtp-cst-lf-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-rep-of-tree-fix-cst (equal (smtp-cst-lf-conc-rep (tree-fix cst)) (smtp-cst-lf-conc-rep cst)))
Theorem:
(defthm smtp-cst-lf-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-lf-conc-rep cst) (smtp-cst-lf-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-sp-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "sp"))) (let ((__function__ 'smtp-cst-sp-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-sp-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-sp-conc-rep (b* ((csts (smtp-cst-sp-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-rep-match (implies (smtp-cst-matchp cst "sp") (b* ((csts (smtp-cst-sp-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-rep-of-tree-fix-cst (equal (smtp-cst-sp-conc-rep (tree-fix cst)) (smtp-cst-sp-conc-rep cst)))
Theorem:
(defthm smtp-cst-sp-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-sp-conc-rep cst) (smtp-cst-sp-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-vchar-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "vchar"))) (let ((__function__ 'smtp-cst-vchar-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-vchar-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-vchar-conc-rep (b* ((csts (smtp-cst-vchar-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-rep-match (implies (smtp-cst-matchp cst "vchar") (b* ((csts (smtp-cst-vchar-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-rep-of-tree-fix-cst (equal (smtp-cst-vchar-conc-rep (tree-fix cst)) (smtp-cst-vchar-conc-rep cst)))
Theorem:
(defthm smtp-cst-vchar-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-vchar-conc-rep cst) (smtp-cst-vchar-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-wsp-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-wsp-conc1 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-wsp-conc1-rep (b* ((csts (smtp-cst-wsp-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-rep-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)) (b* ((csts (smtp-cst-wsp-conc1-rep cst))) (smtp-cst-list-rep-matchp csts "sp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-rep-of-tree-fix-cst (equal (smtp-cst-wsp-conc1-rep (tree-fix cst)) (smtp-cst-wsp-conc1-rep cst)))
Theorem:
(defthm smtp-cst-wsp-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc1-rep cst) (smtp-cst-wsp-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-wsp-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-wsp-conc2 cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-wsp-conc2-rep (b* ((csts (smtp-cst-wsp-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-rep-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)) (b* ((csts (smtp-cst-wsp-conc2-rep cst))) (smtp-cst-list-rep-matchp csts "htab"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-rep-of-tree-fix-cst (equal (smtp-cst-wsp-conc2-rep (tree-fix cst)) (smtp-cst-wsp-conc2-rep cst)))
Theorem:
(defthm smtp-cst-wsp-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc2-rep cst) (smtp-cst-wsp-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-htab-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "htab"))) (let ((__function__ 'smtp-cst-htab-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (smtp-cst-htab-conc cst)))))
Theorem:
(defthm tree-listp-of-smtp-cst-htab-conc-rep (b* ((csts (smtp-cst-htab-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-rep-match (implies (smtp-cst-matchp cst "htab") (b* ((csts (smtp-cst-htab-conc-rep cst))) (smtp-cst-list-rep-matchp csts "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-rep-of-tree-fix-cst (equal (smtp-cst-htab-conc-rep (tree-fix cst)) (smtp-cst-htab-conc-rep cst)))
Theorem:
(defthm smtp-cst-htab-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-htab-conc-rep cst) (smtp-cst-htab-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-forward-path-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "forward-path"))) (let ((__function__ 'smtp-cst-forward-path-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-forward-path-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-forward-path-conc-rep-elem (b* ((cst1 (smtp-cst-forward-path-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-rep-elem-match (implies (smtp-cst-matchp cst "forward-path") (b* ((cst1 (smtp-cst-forward-path-conc-rep-elem cst))) (smtp-cst-matchp cst1 "path"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-forward-path-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-forward-path-conc-rep-elem (tree-fix cst)) (smtp-cst-forward-path-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-forward-path-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-forward-path-conc-rep-elem cst) (smtp-cst-forward-path-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-keyword-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "keyword"))) (let ((__function__ 'smtp-cst-keyword-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-keyword-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-keyword-conc-rep-elem (b* ((cst1 (smtp-cst-keyword-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-rep-elem-match (implies (smtp-cst-matchp cst "keyword") (b* ((cst1 (smtp-cst-keyword-conc-rep-elem cst))) (smtp-cst-matchp cst1 "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-keyword-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-keyword-conc-rep-elem (tree-fix cst)) (smtp-cst-keyword-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-keyword-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-keyword-conc-rep-elem cst) (smtp-cst-keyword-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-argument-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "argument"))) (let ((__function__ 'smtp-cst-argument-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-argument-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-argument-conc-rep-elem (b* ((cst1 (smtp-cst-argument-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-rep-elem-match (implies (smtp-cst-matchp cst "argument") (b* ((cst1 (smtp-cst-argument-conc-rep-elem cst))) (smtp-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-argument-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-argument-conc-rep-elem (tree-fix cst)) (smtp-cst-argument-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-argument-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-argument-conc-rep-elem cst) (smtp-cst-argument-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)))) (let ((__function__ 'smtp-cst-let-dig-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-let-dig-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-let-dig-conc1-rep-elem (b* ((cst1 (smtp-cst-let-dig-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 1)) (b* ((cst1 (smtp-cst-let-dig-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "alpha"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-let-dig-conc1-rep-elem (tree-fix cst)) (smtp-cst-let-dig-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-let-dig-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc1-rep-elem cst) (smtp-cst-let-dig-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-let-dig-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)))) (let ((__function__ 'smtp-cst-let-dig-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-let-dig-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-let-dig-conc2-rep-elem (b* ((cst1 (smtp-cst-let-dig-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "let-dig") (equal (smtp-cst-let-dig-conc? cst) 2)) (b* ((cst1 (smtp-cst-let-dig-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "digit"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-let-dig-conc2-rep-elem (tree-fix cst)) (smtp-cst-let-dig-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-let-dig-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-let-dig-conc2-rep-elem cst) (smtp-cst-let-dig-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-local-part-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-local-part-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-local-part-conc1-rep-elem (b* ((cst1 (smtp-cst-local-part-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 1)) (b* ((cst1 (smtp-cst-local-part-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "dot-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-local-part-conc1-rep-elem (tree-fix cst)) (smtp-cst-local-part-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc1-rep-elem cst) (smtp-cst-local-part-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-local-part-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-local-part-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-local-part-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-local-part-conc2-rep-elem (b* ((cst1 (smtp-cst-local-part-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "local-part") (equal (smtp-cst-local-part-conc? cst) 2)) (b* ((cst1 (smtp-cst-local-part-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-local-part-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-local-part-conc2-rep-elem (tree-fix cst)) (smtp-cst-local-part-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-local-part-conc2-rep-elem cst) (smtp-cst-local-part-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-qcontentsmtp-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-qcontentsmtp-conc1-rep-elem (b* ((cst1 (smtp-cst-qcontentsmtp-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 1)) (b* ((cst1 (smtp-cst-qcontentsmtp-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "qtextsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc1-rep-elem (tree-fix cst)) (smtp-cst-qcontentsmtp-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc1-rep-elem cst) (smtp-cst-qcontentsmtp-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontentsmtp-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontentsmtp-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-qcontentsmtp-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-qcontentsmtp-conc2-rep-elem (b* ((cst1 (smtp-cst-qcontentsmtp-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "qcontentsmtp") (equal (smtp-cst-qcontentsmtp-conc? cst) 2)) (b* ((cst1 (smtp-cst-qcontentsmtp-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-pairsmtp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-qcontentsmtp-conc2-rep-elem (tree-fix cst)) (smtp-cst-qcontentsmtp-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-qcontentsmtp-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontentsmtp-conc2-rep-elem cst) (smtp-cst-qcontentsmtp-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)))) (let ((__function__ 'smtp-cst-string-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-string-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-string-conc1-rep-elem (b* ((cst1 (smtp-cst-string-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 1)) (b* ((cst1 (smtp-cst-string-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-string-conc1-rep-elem (tree-fix cst)) (smtp-cst-string-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-string-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc1-rep-elem cst) (smtp-cst-string-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-string-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)))) (let ((__function__ 'smtp-cst-string-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-string-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-string-conc2-rep-elem (b* ((cst1 (smtp-cst-string-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "string") (equal (smtp-cst-string-conc? cst) 2)) (b* ((cst1 (smtp-cst-string-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-string-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-string-conc2-rep-elem (tree-fix cst)) (smtp-cst-string-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-string-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-string-conc2-rep-elem cst) (smtp-cst-string-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-standardized-tag-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag"))) (let ((__function__ 'smtp-cst-standardized-tag-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-standardized-tag-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-standardized-tag-conc-rep-elem (b* ((cst1 (smtp-cst-standardized-tag-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-elem-match (implies (smtp-cst-matchp cst "standardized-tag") (b* ((cst1 (smtp-cst-standardized-tag-conc-rep-elem cst))) (smtp-cst-matchp cst1 "ldh-str"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-standardized-tag-conc-rep-elem (tree-fix cst)) (smtp-cst-standardized-tag-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-standardized-tag-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-standardized-tag-conc-rep-elem cst) (smtp-cst-standardized-tag-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ipv6-addr-conc1-rep-elem (b* ((cst1 (smtp-cst-ipv6-addr-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 1)) (b* ((cst1 (smtp-cst-ipv6-addr-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "ipv6-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc1-rep-elem (tree-fix cst)) (smtp-cst-ipv6-addr-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc1-rep-elem cst) (smtp-cst-ipv6-addr-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ipv6-addr-conc2-rep-elem (b* ((cst1 (smtp-cst-ipv6-addr-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 2)) (b* ((cst1 (smtp-cst-ipv6-addr-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "ipv6-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc2-rep-elem (tree-fix cst)) (smtp-cst-ipv6-addr-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc2-rep-elem cst) (smtp-cst-ipv6-addr-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc3-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ipv6-addr-conc3-rep-elem (b* ((cst1 (smtp-cst-ipv6-addr-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-elem-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 3)) (b* ((cst1 (smtp-cst-ipv6-addr-conc3-rep-elem cst))) (smtp-cst-matchp cst1 "ipv6v4-full"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-elem-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc3-rep-elem (tree-fix cst)) (smtp-cst-ipv6-addr-conc3-rep-elem cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc3-rep-elem cst) (smtp-cst-ipv6-addr-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ipv6-addr-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)))) (let ((__function__ 'smtp-cst-ipv6-addr-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc4-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ipv6-addr-conc4-rep-elem (b* ((cst1 (smtp-cst-ipv6-addr-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-elem-match (implies (and (smtp-cst-matchp cst "ipv6-addr") (equal (smtp-cst-ipv6-addr-conc? cst) 4)) (b* ((cst1 (smtp-cst-ipv6-addr-conc4-rep-elem cst))) (smtp-cst-matchp cst1 "ipv6v4-comp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-elem-of-tree-fix-cst (equal (smtp-cst-ipv6-addr-conc4-rep-elem (tree-fix cst)) (smtp-cst-ipv6-addr-conc4-rep-elem cst)))
Theorem:
(defthm smtp-cst-ipv6-addr-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ipv6-addr-conc4-rep-elem cst) (smtp-cst-ipv6-addr-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-addtl-link-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "addtl-link"))) (let ((__function__ 'smtp-cst-addtl-link-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-addtl-link-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-addtl-link-conc-rep-elem (b* ((cst1 (smtp-cst-addtl-link-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-elem-match (implies (smtp-cst-matchp cst "addtl-link") (b* ((cst1 (smtp-cst-addtl-link-conc-rep-elem cst))) (smtp-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-addtl-link-conc-rep-elem (tree-fix cst)) (smtp-cst-addtl-link-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-addtl-link-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-addtl-link-conc-rep-elem cst) (smtp-cst-addtl-link-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-attdl-protocol-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol"))) (let ((__function__ 'smtp-cst-attdl-protocol-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-attdl-protocol-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-attdl-protocol-conc-rep-elem (b* ((cst1 (smtp-cst-attdl-protocol-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-elem-match (implies (smtp-cst-matchp cst "attdl-protocol") (b* ((cst1 (smtp-cst-attdl-protocol-conc-rep-elem cst))) (smtp-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-attdl-protocol-conc-rep-elem (tree-fix cst)) (smtp-cst-attdl-protocol-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-attdl-protocol-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-attdl-protocol-conc-rep-elem cst) (smtp-cst-attdl-protocol-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-ccontent-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ccontent-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ccontent-conc1-rep-elem (b* ((cst1 (smtp-cst-ccontent-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 1)) (b* ((cst1 (smtp-cst-ccontent-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-ccontent-conc1-rep-elem (tree-fix cst)) (smtp-cst-ccontent-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-ccontent-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc1-rep-elem cst) (smtp-cst-ccontent-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-ccontent-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ccontent-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ccontent-conc2-rep-elem (b* ((cst1 (smtp-cst-ccontent-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 2)) (b* ((cst1 (smtp-cst-ccontent-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-ccontent-conc2-rep-elem (tree-fix cst)) (smtp-cst-ccontent-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-ccontent-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc2-rep-elem cst) (smtp-cst-ccontent-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-ccontent-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'smtp-cst-ccontent-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-ccontent-conc3-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-ccontent-conc3-rep-elem (b* ((cst1 (smtp-cst-ccontent-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-elem-match (implies (and (smtp-cst-matchp cst "ccontent") (equal (smtp-cst-ccontent-conc? cst) 3)) (b* ((cst1 (smtp-cst-ccontent-conc3-rep-elem cst))) (smtp-cst-matchp cst1 "comment"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-elem-of-tree-fix-cst (equal (smtp-cst-ccontent-conc3-rep-elem (tree-fix cst)) (smtp-cst-ccontent-conc3-rep-elem cst)))
Theorem:
(defthm smtp-cst-ccontent-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-ccontent-conc3-rep-elem cst) (smtp-cst-ccontent-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-left-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-id-left-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-id-left-conc1-rep-elem (b* ((cst1 (smtp-cst-id-left-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 1)) (b* ((cst1 (smtp-cst-id-left-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-id-left-conc1-rep-elem (tree-fix cst)) (smtp-cst-id-left-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-id-left-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc1-rep-elem cst) (smtp-cst-id-left-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-left-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-left-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-id-left-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-id-left-conc2-rep-elem (b* ((cst1 (smtp-cst-id-left-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "id-left") (equal (smtp-cst-id-left-conc? cst) 2)) (b* ((cst1 (smtp-cst-id-left-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-left-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-id-left-conc2-rep-elem (tree-fix cst)) (smtp-cst-id-left-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-id-left-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-left-conc2-rep-elem cst) (smtp-cst-id-left-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)))) (let ((__function__ 'smtp-cst-id-right-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-id-right-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-id-right-conc1-rep-elem (b* ((cst1 (smtp-cst-id-right-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 1)) (b* ((cst1 (smtp-cst-id-right-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-id-right-conc1-rep-elem (tree-fix cst)) (smtp-cst-id-right-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-id-right-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc1-rep-elem cst) (smtp-cst-id-right-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)))) (let ((__function__ 'smtp-cst-id-right-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-id-right-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-id-right-conc2-rep-elem (b* ((cst1 (smtp-cst-id-right-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 2)) (b* ((cst1 (smtp-cst-id-right-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-id-right-conc2-rep-elem (tree-fix cst)) (smtp-cst-id-right-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-id-right-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc2-rep-elem cst) (smtp-cst-id-right-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-id-right-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)))) (let ((__function__ 'smtp-cst-id-right-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-id-right-conc3-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-id-right-conc3-rep-elem (b* ((cst1 (smtp-cst-id-right-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-rep-elem-match (implies (and (smtp-cst-matchp cst "id-right") (equal (smtp-cst-id-right-conc? cst) 3)) (b* ((cst1 (smtp-cst-id-right-conc3-rep-elem cst))) (smtp-cst-matchp cst1 "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-id-right-conc3-rep-elem-of-tree-fix-cst (equal (smtp-cst-id-right-conc3-rep-elem (tree-fix cst)) (smtp-cst-id-right-conc3-rep-elem cst)))
Theorem:
(defthm smtp-cst-id-right-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-id-right-conc3-rep-elem cst) (smtp-cst-id-right-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-ctext-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext"))) (let ((__function__ 'smtp-cst-obs-ctext-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-ctext-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-ctext-conc-rep-elem (b* ((cst1 (smtp-cst-obs-ctext-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-elem-match (implies (smtp-cst-matchp cst "obs-ctext") (b* ((cst1 (smtp-cst-obs-ctext-conc-rep-elem cst))) (smtp-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-ctext-conc-rep-elem (tree-fix cst)) (smtp-cst-obs-ctext-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-ctext-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-ctext-conc-rep-elem cst) (smtp-cst-obs-ctext-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'smtp-cst-obs-dtext-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-dtext-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-dtext-conc1-rep-elem (b* ((cst1 (smtp-cst-obs-dtext-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 1)) (b* ((cst1 (smtp-cst-obs-dtext-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc1-rep-elem (tree-fix cst)) (smtp-cst-obs-dtext-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc1-rep-elem cst) (smtp-cst-obs-dtext-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-dtext-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'smtp-cst-obs-dtext-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-dtext-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-dtext-conc2-rep-elem (b* ((cst1 (smtp-cst-obs-dtext-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "obs-dtext") (equal (smtp-cst-obs-dtext-conc? cst) 2)) (b* ((cst1 (smtp-cst-obs-dtext-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-dtext-conc2-rep-elem (tree-fix cst)) (smtp-cst-obs-dtext-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-dtext-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-dtext-conc2-rep-elem cst) (smtp-cst-obs-dtext-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-left-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left"))) (let ((__function__ 'smtp-cst-obs-id-left-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-id-left-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-id-left-conc-rep-elem (b* ((cst1 (smtp-cst-obs-id-left-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-elem-match (implies (smtp-cst-matchp cst "obs-id-left") (b* ((cst1 (smtp-cst-obs-id-left-conc-rep-elem cst))) (smtp-cst-matchp cst1 "imf-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-id-left-conc-rep-elem (tree-fix cst)) (smtp-cst-obs-id-left-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-id-left-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-left-conc-rep-elem cst) (smtp-cst-obs-id-left-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-local-part-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-local-part-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-local-part-conc1-rep-elem (b* ((cst1 (smtp-cst-imf-local-part-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 1)) (b* ((cst1 (smtp-cst-imf-local-part-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc1-rep-elem (tree-fix cst)) (smtp-cst-imf-local-part-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc1-rep-elem cst) (smtp-cst-imf-local-part-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-local-part-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-local-part-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-local-part-conc2-rep-elem (b* ((cst1 (smtp-cst-imf-local-part-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 2)) (b* ((cst1 (smtp-cst-imf-local-part-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc2-rep-elem (tree-fix cst)) (smtp-cst-imf-local-part-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc2-rep-elem cst) (smtp-cst-imf-local-part-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-local-part-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-local-part-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-local-part-conc3-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-local-part-conc3-rep-elem (b* ((cst1 (smtp-cst-imf-local-part-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-local-part") (equal (smtp-cst-imf-local-part-conc? cst) 3)) (b* ((cst1 (smtp-cst-imf-local-part-conc3-rep-elem cst))) (smtp-cst-matchp cst1 "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-local-part-conc3-rep-elem (tree-fix cst)) (smtp-cst-imf-local-part-conc3-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-local-part-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-local-part-conc3-rep-elem cst) (smtp-cst-imf-local-part-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-id-right-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right"))) (let ((__function__ 'smtp-cst-obs-id-right-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-id-right-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-id-right-conc-rep-elem (b* ((cst1 (smtp-cst-obs-id-right-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-elem-match (implies (smtp-cst-matchp cst "obs-id-right") (b* ((cst1 (smtp-cst-obs-id-right-conc-rep-elem cst))) (smtp-cst-matchp cst1 "imf-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-id-right-conc-rep-elem (tree-fix cst)) (smtp-cst-obs-id-right-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-id-right-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-id-right-conc-rep-elem cst) (smtp-cst-obs-id-right-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)))) (let ((__function__ 'smtp-cst-imf-domain-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-domain-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-domain-conc1-rep-elem (b* ((cst1 (smtp-cst-imf-domain-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 1)) (b* ((cst1 (smtp-cst-imf-domain-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc1-rep-elem (tree-fix cst)) (smtp-cst-imf-domain-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc1-rep-elem cst) (smtp-cst-imf-domain-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)))) (let ((__function__ 'smtp-cst-imf-domain-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-domain-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-domain-conc2-rep-elem (b* ((cst1 (smtp-cst-imf-domain-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 2)) (b* ((cst1 (smtp-cst-imf-domain-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc2-rep-elem (tree-fix cst)) (smtp-cst-imf-domain-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc2-rep-elem cst) (smtp-cst-imf-domain-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-imf-domain-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)))) (let ((__function__ 'smtp-cst-imf-domain-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-imf-domain-conc3-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-imf-domain-conc3-rep-elem (b* ((cst1 (smtp-cst-imf-domain-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-elem-match (implies (and (smtp-cst-matchp cst "imf-domain") (equal (smtp-cst-imf-domain-conc? cst) 3)) (b* ((cst1 (smtp-cst-imf-domain-conc3-rep-elem cst))) (smtp-cst-matchp cst1 "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-elem-of-tree-fix-cst (equal (smtp-cst-imf-domain-conc3-rep-elem (tree-fix cst)) (smtp-cst-imf-domain-conc3-rep-elem cst)))
Theorem:
(defthm smtp-cst-imf-domain-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-imf-domain-conc3-rep-elem cst) (smtp-cst-imf-domain-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'smtp-cst-qcontent-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-qcontent-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-qcontent-conc1-rep-elem (b* ((cst1 (smtp-cst-qcontent-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 1)) (b* ((cst1 (smtp-cst-qcontent-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-qcontent-conc1-rep-elem (tree-fix cst)) (smtp-cst-qcontent-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-qcontent-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc1-rep-elem cst) (smtp-cst-qcontent-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-qcontent-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'smtp-cst-qcontent-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-qcontent-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-qcontent-conc2-rep-elem (b* ((cst1 (smtp-cst-qcontent-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "qcontent") (equal (smtp-cst-qcontent-conc? cst) 2)) (b* ((cst1 (smtp-cst-qcontent-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-qcontent-conc2-rep-elem (tree-fix cst)) (smtp-cst-qcontent-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-qcontent-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-qcontent-conc2-rep-elem cst) (smtp-cst-qcontent-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-obs-qtext-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext"))) (let ((__function__ 'smtp-cst-obs-qtext-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-obs-qtext-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-obs-qtext-conc-rep-elem (b* ((cst1 (smtp-cst-obs-qtext-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-elem-match (implies (smtp-cst-matchp cst "obs-qtext") (b* ((cst1 (smtp-cst-obs-qtext-conc-rep-elem cst))) (smtp-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-obs-qtext-conc-rep-elem (tree-fix cst)) (smtp-cst-obs-qtext-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-obs-qtext-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-obs-qtext-conc-rep-elem cst) (smtp-cst-obs-qtext-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)))) (let ((__function__ 'smtp-cst-word-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-word-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-word-conc1-rep-elem (b* ((cst1 (smtp-cst-word-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 1)) (b* ((cst1 (smtp-cst-word-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "imf-atom"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-word-conc1-rep-elem (tree-fix cst)) (smtp-cst-word-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-word-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc1-rep-elem cst) (smtp-cst-word-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-word-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)))) (let ((__function__ 'smtp-cst-word-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-word-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-word-conc2-rep-elem (b* ((cst1 (smtp-cst-word-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "word") (equal (smtp-cst-word-conc? cst) 2)) (b* ((cst1 (smtp-cst-word-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "imf-quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-word-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-word-conc2-rep-elem (tree-fix cst)) (smtp-cst-word-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-word-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-word-conc2-rep-elem cst) (smtp-cst-word-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-cr-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "cr"))) (let ((__function__ 'smtp-cst-cr-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-cr-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-cr-conc-rep-elem (b* ((cst1 (smtp-cst-cr-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-rep-elem-match (implies (smtp-cst-matchp cst "cr") (b* ((cst1 (smtp-cst-cr-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-cr-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-cr-conc-rep-elem (tree-fix cst)) (smtp-cst-cr-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-cr-conc-rep-elem cst) (smtp-cst-cr-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-digit-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "digit"))) (let ((__function__ 'smtp-cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-digit-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-digit-conc-rep-elem (b* ((cst1 (smtp-cst-digit-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-rep-elem-match (implies (smtp-cst-matchp cst "digit") (b* ((cst1 (smtp-cst-digit-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-digit-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-digit-conc-rep-elem (tree-fix cst)) (smtp-cst-digit-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-digit-conc-rep-elem cst) (smtp-cst-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-dquote-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "dquote"))) (let ((__function__ 'smtp-cst-dquote-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-dquote-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-dquote-conc-rep-elem (b* ((cst1 (smtp-cst-dquote-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-rep-elem-match (implies (smtp-cst-matchp cst "dquote") (b* ((cst1 (smtp-cst-dquote-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-dquote-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-dquote-conc-rep-elem (tree-fix cst)) (smtp-cst-dquote-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-dquote-conc-rep-elem cst) (smtp-cst-dquote-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-lf-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "lf"))) (let ((__function__ 'smtp-cst-lf-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-lf-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-lf-conc-rep-elem (b* ((cst1 (smtp-cst-lf-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-rep-elem-match (implies (smtp-cst-matchp cst "lf") (b* ((cst1 (smtp-cst-lf-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-lf-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-lf-conc-rep-elem (tree-fix cst)) (smtp-cst-lf-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-lf-conc-rep-elem cst) (smtp-cst-lf-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-sp-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "sp"))) (let ((__function__ 'smtp-cst-sp-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-sp-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-sp-conc-rep-elem (b* ((cst1 (smtp-cst-sp-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-rep-elem-match (implies (smtp-cst-matchp cst "sp") (b* ((cst1 (smtp-cst-sp-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-sp-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-sp-conc-rep-elem (tree-fix cst)) (smtp-cst-sp-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-sp-conc-rep-elem cst) (smtp-cst-sp-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-vchar-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "vchar"))) (let ((__function__ 'smtp-cst-vchar-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-vchar-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-vchar-conc-rep-elem (b* ((cst1 (smtp-cst-vchar-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-rep-elem-match (implies (smtp-cst-matchp cst "vchar") (b* ((cst1 (smtp-cst-vchar-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-vchar-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-vchar-conc-rep-elem (tree-fix cst)) (smtp-cst-vchar-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-vchar-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-vchar-conc-rep-elem cst) (smtp-cst-vchar-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)))) (let ((__function__ 'smtp-cst-wsp-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-wsp-conc1-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-wsp-conc1-rep-elem (b* ((cst1 (smtp-cst-wsp-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-rep-elem-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 1)) (b* ((cst1 (smtp-cst-wsp-conc1-rep-elem cst))) (smtp-cst-matchp cst1 "sp"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc1-rep-elem-of-tree-fix-cst (equal (smtp-cst-wsp-conc1-rep-elem (tree-fix cst)) (smtp-cst-wsp-conc1-rep-elem cst)))
Theorem:
(defthm smtp-cst-wsp-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc1-rep-elem cst) (smtp-cst-wsp-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-wsp-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)))) (let ((__function__ 'smtp-cst-wsp-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-wsp-conc2-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-wsp-conc2-rep-elem (b* ((cst1 (smtp-cst-wsp-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-rep-elem-match (implies (and (smtp-cst-matchp cst "wsp") (equal (smtp-cst-wsp-conc? cst) 2)) (b* ((cst1 (smtp-cst-wsp-conc2-rep-elem cst))) (smtp-cst-matchp cst1 "htab"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-wsp-conc2-rep-elem-of-tree-fix-cst (equal (smtp-cst-wsp-conc2-rep-elem (tree-fix cst)) (smtp-cst-wsp-conc2-rep-elem cst)))
Theorem:
(defthm smtp-cst-wsp-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-wsp-conc2-rep-elem cst) (smtp-cst-wsp-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun smtp-cst-htab-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (smtp-cst-matchp cst "htab"))) (let ((__function__ 'smtp-cst-htab-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (smtp-cst-htab-conc-rep cst)))))
Theorem:
(defthm treep-of-smtp-cst-htab-conc-rep-elem (b* ((cst1 (smtp-cst-htab-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-rep-elem-match (implies (smtp-cst-matchp cst "htab") (b* ((cst1 (smtp-cst-htab-conc-rep-elem cst))) (smtp-cst-matchp cst1 "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm smtp-cst-htab-conc-rep-elem-of-tree-fix-cst (equal (smtp-cst-htab-conc-rep-elem (tree-fix cst)) (smtp-cst-htab-conc-rep-elem cst)))
Theorem:
(defthm smtp-cst-htab-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (smtp-cst-htab-conc-rep-elem cst) (smtp-cst-htab-conc-rep-elem cst-equiv))) :rule-classes :congruence)