Tree operations specialized to *all-imf-grammar-rules*.
Function:
(defun imf-cst-matchp$ (tree elem) (declare (xargs :guard (and (treep tree) (elementp elem)))) (let ((__function__ 'imf-cst-matchp$)) (declare (ignorable __function__)) (and (tree-terminatedp tree) (tree-match-element-p tree elem *all-imf-grammar-rules*))))
Theorem:
(defthm booleanp-of-imf-cst-matchp$ (b* ((yes/no (imf-cst-matchp$ tree elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-matchp$-of-tree-fix-tree (equal (imf-cst-matchp$ (tree-fix tree) elem) (imf-cst-matchp$ tree elem)))
Theorem:
(defthm imf-cst-matchp$-tree-equiv-congruence-on-tree (implies (tree-equiv tree tree-equiv) (equal (imf-cst-matchp$ tree elem) (imf-cst-matchp$ tree-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-matchp$-of-element-fix-elem (equal (imf-cst-matchp$ tree (element-fix elem)) (imf-cst-matchp$ tree elem)))
Theorem:
(defthm imf-cst-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (imf-cst-matchp$ tree elem) (imf-cst-matchp$ tree elem-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-list-elem-matchp$ (trees elem) (declare (xargs :guard (and (tree-listp trees) (elementp elem)))) (let ((__function__ 'imf-cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-element-p trees elem *all-imf-grammar-rules*))))
Theorem:
(defthm booleanp-of-imf-cst-list-elem-matchp$ (b* ((yes/no (imf-cst-list-elem-matchp$ trees elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-list-elem-matchp$-of-tree-list-fix-trees (equal (imf-cst-list-elem-matchp$ (tree-list-fix trees) elem) (imf-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm imf-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (imf-cst-list-elem-matchp$ trees elem) (imf-cst-list-elem-matchp$ trees-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-list-elem-matchp$-of-element-fix-elem (equal (imf-cst-list-elem-matchp$ trees (element-fix elem)) (imf-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm imf-cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (imf-cst-list-elem-matchp$ trees elem) (imf-cst-list-elem-matchp$ trees elem-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-list-rep-matchp$ (trees rep) (declare (xargs :guard (and (tree-listp trees) (repetitionp rep)))) (let ((__function__ 'imf-cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-repetition-p trees rep *all-imf-grammar-rules*))))
Theorem:
(defthm booleanp-of-imf-cst-list-rep-matchp$ (b* ((yes/no (imf-cst-list-rep-matchp$ trees rep))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-list-rep-matchp$-of-tree-list-fix-trees (equal (imf-cst-list-rep-matchp$ (tree-list-fix trees) rep) (imf-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm imf-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (imf-cst-list-rep-matchp$ trees rep) (imf-cst-list-rep-matchp$ trees-equiv rep))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-list-rep-matchp$-of-repetition-fix-rep (equal (imf-cst-list-rep-matchp$ trees (repetition-fix rep)) (imf-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm imf-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (repetition-equiv rep rep-equiv) (equal (imf-cst-list-rep-matchp$ trees rep) (imf-cst-list-rep-matchp$ trees rep-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-list-list-conc-matchp$ (treess conc) (declare (xargs :guard (and (tree-list-listp treess) (concatenationp conc)))) (let ((__function__ 'imf-cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-concatenation-p treess conc *all-imf-grammar-rules*))))
Theorem:
(defthm booleanp-of-imf-cst-list-list-conc-matchp$ (b* ((yes/no (imf-cst-list-list-conc-matchp$ treess conc))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (imf-cst-list-list-conc-matchp$ (tree-list-list-fix treess) conc) (imf-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm imf-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (imf-cst-list-list-conc-matchp$ treess conc) (imf-cst-list-list-conc-matchp$ treess-equiv conc))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (imf-cst-list-list-conc-matchp$ treess (concatenation-fix conc)) (imf-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm imf-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (concatenation-equiv conc conc-equiv) (equal (imf-cst-list-list-conc-matchp$ treess conc) (imf-cst-list-list-conc-matchp$ treess conc-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-list-list-alt-matchp$ (treess alt) (declare (xargs :guard (and (tree-list-listp treess) (alternationp alt)))) (let ((__function__ 'imf-cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-alternation-p treess alt *all-imf-grammar-rules*))))
Theorem:
(defthm booleanp-of-imf-cst-list-list-alt-matchp$ (b* ((yes/no (imf-cst-list-list-alt-matchp$ treess alt))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (imf-cst-list-list-alt-matchp$ (tree-list-list-fix treess) alt) (imf-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm imf-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (imf-cst-list-list-alt-matchp$ treess alt) (imf-cst-list-list-alt-matchp$ treess-equiv alt))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (imf-cst-list-list-alt-matchp$ treess (alternation-fix alt)) (imf-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm imf-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (alternation-equiv alt alt-equiv) (equal (imf-cst-list-list-alt-matchp$ treess alt) (imf-cst-list-list-alt-matchp$ treess alt-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d1-8-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d1-8"))) (let ((__function__ 'imf-cst-%d1-8-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d1-8-nat (b* ((nat (imf-cst-%d1-8-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d1-8-nat-of-tree-fix-cst (equal (imf-cst-%d1-8-nat (tree-fix cst)) (imf-cst-%d1-8-nat cst)))
Theorem:
(defthm imf-cst-%d1-8-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d1-8-nat cst) (imf-cst-%d1-8-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d1-9-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d1-9"))) (let ((__function__ 'imf-cst-%d1-9-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d1-9-nat (b* ((nat (imf-cst-%d1-9-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d1-9-nat-of-tree-fix-cst (equal (imf-cst-%d1-9-nat (tree-fix cst)) (imf-cst-%d1-9-nat cst)))
Theorem:
(defthm imf-cst-%d1-9-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d1-9-nat cst) (imf-cst-%d1-9-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d14-31-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d14-31"))) (let ((__function__ 'imf-cst-%d14-31-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d14-31-nat (b* ((nat (imf-cst-%d14-31-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d14-31-nat-of-tree-fix-cst (equal (imf-cst-%d14-31-nat (tree-fix cst)) (imf-cst-%d14-31-nat cst)))
Theorem:
(defthm imf-cst-%d14-31-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d14-31-nat cst) (imf-cst-%d14-31-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d14-127-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d14-127"))) (let ((__function__ 'imf-cst-%d14-127-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d14-127-nat (b* ((nat (imf-cst-%d14-127-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d14-127-nat-of-tree-fix-cst (equal (imf-cst-%d14-127-nat (tree-fix cst)) (imf-cst-%d14-127-nat cst)))
Theorem:
(defthm imf-cst-%d14-127-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d14-127-nat cst) (imf-cst-%d14-127-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d33-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d33-39"))) (let ((__function__ 'imf-cst-%d33-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d33-39-nat (b* ((nat (imf-cst-%d33-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d33-39-nat-of-tree-fix-cst (equal (imf-cst-%d33-39-nat (tree-fix cst)) (imf-cst-%d33-39-nat cst)))
Theorem:
(defthm imf-cst-%d33-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d33-39-nat cst) (imf-cst-%d33-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d33-57-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d33-57"))) (let ((__function__ 'imf-cst-%d33-57-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d33-57-nat (b* ((nat (imf-cst-%d33-57-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d33-57-nat-of-tree-fix-cst (equal (imf-cst-%d33-57-nat (tree-fix cst)) (imf-cst-%d33-57-nat cst)))
Theorem:
(defthm imf-cst-%d33-57-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d33-57-nat cst) (imf-cst-%d33-57-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d33-90-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d33-90"))) (let ((__function__ 'imf-cst-%d33-90-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d33-90-nat (b* ((nat (imf-cst-%d33-90-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d33-90-nat-of-tree-fix-cst (equal (imf-cst-%d33-90-nat (tree-fix cst)) (imf-cst-%d33-90-nat cst)))
Theorem:
(defthm imf-cst-%d33-90-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d33-90-nat cst) (imf-cst-%d33-90-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d35-91-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d35-91"))) (let ((__function__ 'imf-cst-%d35-91-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d35-91-nat (b* ((nat (imf-cst-%d35-91-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d35-91-nat-of-tree-fix-cst (equal (imf-cst-%d35-91-nat (tree-fix cst)) (imf-cst-%d35-91-nat cst)))
Theorem:
(defthm imf-cst-%d35-91-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d35-91-nat cst) (imf-cst-%d35-91-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d42-91-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d42-91"))) (let ((__function__ 'imf-cst-%d42-91-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d42-91-nat (b* ((nat (imf-cst-%d42-91-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d42-91-nat-of-tree-fix-cst (equal (imf-cst-%d42-91-nat (tree-fix cst)) (imf-cst-%d42-91-nat cst)))
Theorem:
(defthm imf-cst-%d42-91-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d42-91-nat cst) (imf-cst-%d42-91-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d59-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d59-126"))) (let ((__function__ 'imf-cst-%d59-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d59-126-nat (b* ((nat (imf-cst-%d59-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d59-126-nat-of-tree-fix-cst (equal (imf-cst-%d59-126-nat (tree-fix cst)) (imf-cst-%d59-126-nat cst)))
Theorem:
(defthm imf-cst-%d59-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d59-126-nat cst) (imf-cst-%d59-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d65-73-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d65-73"))) (let ((__function__ 'imf-cst-%d65-73-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d65-73-nat (b* ((nat (imf-cst-%d65-73-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d65-73-nat-of-tree-fix-cst (equal (imf-cst-%d65-73-nat (tree-fix cst)) (imf-cst-%d65-73-nat cst)))
Theorem:
(defthm imf-cst-%d65-73-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d65-73-nat cst) (imf-cst-%d65-73-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d75-90-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d75-90"))) (let ((__function__ 'imf-cst-%d75-90-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d75-90-nat (b* ((nat (imf-cst-%d75-90-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d75-90-nat-of-tree-fix-cst (equal (imf-cst-%d75-90-nat (tree-fix cst)) (imf-cst-%d75-90-nat cst)))
Theorem:
(defthm imf-cst-%d75-90-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d75-90-nat cst) (imf-cst-%d75-90-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d93-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d93-126"))) (let ((__function__ 'imf-cst-%d93-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d93-126-nat (b* ((nat (imf-cst-%d93-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d93-126-nat-of-tree-fix-cst (equal (imf-cst-%d93-126-nat (tree-fix cst)) (imf-cst-%d93-126-nat cst)))
Theorem:
(defthm imf-cst-%d93-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d93-126-nat cst) (imf-cst-%d93-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d94-126-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d94-126"))) (let ((__function__ 'imf-cst-%d94-126-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d94-126-nat (b* ((nat (imf-cst-%d94-126-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d94-126-nat-of-tree-fix-cst (equal (imf-cst-%d94-126-nat (tree-fix cst)) (imf-cst-%d94-126-nat cst)))
Theorem:
(defthm imf-cst-%d94-126-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d94-126-nat cst) (imf-cst-%d94-126-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d97-105-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d97-105"))) (let ((__function__ 'imf-cst-%d97-105-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d97-105-nat (b* ((nat (imf-cst-%d97-105-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d97-105-nat-of-tree-fix-cst (equal (imf-cst-%d97-105-nat (tree-fix cst)) (imf-cst-%d97-105-nat cst)))
Theorem:
(defthm imf-cst-%d97-105-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d97-105-nat cst) (imf-cst-%d97-105-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%d107-122-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%d107-122"))) (let ((__function__ 'imf-cst-%d107-122-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%d107-122-nat (b* ((nat (imf-cst-%d107-122-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%d107-122-nat-of-tree-fix-cst (equal (imf-cst-%d107-122-nat (tree-fix cst)) (imf-cst-%d107-122-nat cst)))
Theorem:
(defthm imf-cst-%d107-122-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%d107-122-nat cst) (imf-cst-%d107-122-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%x21-7e-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%x21-7E"))) (let ((__function__ 'imf-cst-%x21-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%x21-7e-nat (b* ((nat (imf-cst-%x21-7e-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%x21-7e-nat-of-tree-fix-cst (equal (imf-cst-%x21-7e-nat (tree-fix cst)) (imf-cst-%x21-7e-nat cst)))
Theorem:
(defthm imf-cst-%x21-7e-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%x21-7e-nat cst) (imf-cst-%x21-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%x30-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%x30-39"))) (let ((__function__ 'imf-cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%x30-39-nat (b* ((nat (imf-cst-%x30-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%x30-39-nat-of-tree-fix-cst (equal (imf-cst-%x30-39-nat (tree-fix cst)) (imf-cst-%x30-39-nat cst)))
Theorem:
(defthm imf-cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%x30-39-nat cst) (imf-cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%x41-5a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%x41-5A"))) (let ((__function__ 'imf-cst-%x41-5a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%x41-5a-nat (b* ((nat (imf-cst-%x41-5a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%x41-5a-nat-of-tree-fix-cst (equal (imf-cst-%x41-5a-nat (tree-fix cst)) (imf-cst-%x41-5a-nat cst)))
Theorem:
(defthm imf-cst-%x41-5a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%x41-5a-nat cst) (imf-cst-%x41-5a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-%x61-7a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "%x61-7A"))) (let ((__function__ 'imf-cst-%x61-7a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imf-cst-%x61-7a-nat (b* ((nat (imf-cst-%x61-7a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-%x61-7a-nat-of-tree-fix-cst (equal (imf-cst-%x61-7a-nat (tree-fix cst)) (imf-cst-%x61-7a-nat cst)))
Theorem:
(defthm imf-cst-%x61-7a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-%x61-7a-nat cst) (imf-cst-%x61-7a-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-%d1-8-nat-bounds (implies (imf-cst-matchp cst "%d1-8") (and (<= 1 (imf-cst-%d1-8-nat cst)) (<= (imf-cst-%d1-8-nat cst) 8))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d1-9-nat-bounds (implies (imf-cst-matchp cst "%d1-9") (and (<= 1 (imf-cst-%d1-9-nat cst)) (<= (imf-cst-%d1-9-nat cst) 9))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d14-31-nat-bounds (implies (imf-cst-matchp cst "%d14-31") (and (<= 14 (imf-cst-%d14-31-nat cst)) (<= (imf-cst-%d14-31-nat cst) 31))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d14-127-nat-bounds (implies (imf-cst-matchp cst "%d14-127") (and (<= 14 (imf-cst-%d14-127-nat cst)) (<= (imf-cst-%d14-127-nat cst) 127))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d33-39-nat-bounds (implies (imf-cst-matchp cst "%d33-39") (and (<= 33 (imf-cst-%d33-39-nat cst)) (<= (imf-cst-%d33-39-nat cst) 39))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d33-57-nat-bounds (implies (imf-cst-matchp cst "%d33-57") (and (<= 33 (imf-cst-%d33-57-nat cst)) (<= (imf-cst-%d33-57-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d33-90-nat-bounds (implies (imf-cst-matchp cst "%d33-90") (and (<= 33 (imf-cst-%d33-90-nat cst)) (<= (imf-cst-%d33-90-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d35-91-nat-bounds (implies (imf-cst-matchp cst "%d35-91") (and (<= 35 (imf-cst-%d35-91-nat cst)) (<= (imf-cst-%d35-91-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d42-91-nat-bounds (implies (imf-cst-matchp cst "%d42-91") (and (<= 42 (imf-cst-%d42-91-nat cst)) (<= (imf-cst-%d42-91-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d59-126-nat-bounds (implies (imf-cst-matchp cst "%d59-126") (and (<= 59 (imf-cst-%d59-126-nat cst)) (<= (imf-cst-%d59-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d65-73-nat-bounds (implies (imf-cst-matchp cst "%d65-73") (and (<= 65 (imf-cst-%d65-73-nat cst)) (<= (imf-cst-%d65-73-nat cst) 73))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d75-90-nat-bounds (implies (imf-cst-matchp cst "%d75-90") (and (<= 75 (imf-cst-%d75-90-nat cst)) (<= (imf-cst-%d75-90-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d93-126-nat-bounds (implies (imf-cst-matchp cst "%d93-126") (and (<= 93 (imf-cst-%d93-126-nat cst)) (<= (imf-cst-%d93-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d94-126-nat-bounds (implies (imf-cst-matchp cst "%d94-126") (and (<= 94 (imf-cst-%d94-126-nat cst)) (<= (imf-cst-%d94-126-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d97-105-nat-bounds (implies (imf-cst-matchp cst "%d97-105") (and (<= 97 (imf-cst-%d97-105-nat cst)) (<= (imf-cst-%d97-105-nat cst) 105))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%d107-122-nat-bounds (implies (imf-cst-matchp cst "%d107-122") (and (<= 107 (imf-cst-%d107-122-nat cst)) (<= (imf-cst-%d107-122-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%x21-7e-nat-bounds (implies (imf-cst-matchp cst "%x21-7E") (and (<= 33 (imf-cst-%x21-7e-nat cst)) (<= (imf-cst-%x21-7e-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%x30-39-nat-bounds (implies (imf-cst-matchp cst "%x30-39") (and (<= 48 (imf-cst-%x30-39-nat cst)) (<= (imf-cst-%x30-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%x41-5a-nat-bounds (implies (imf-cst-matchp cst "%x41-5A") (and (<= 65 (imf-cst-%x41-5a-nat cst)) (<= (imf-cst-%x41-5a-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm imf-cst-%x61-7a-nat-bounds (implies (imf-cst-matchp cst "%x61-7A") (and (<= 97 (imf-cst-%x61-7a-nat cst)) (<= (imf-cst-%x61-7a-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm |IMF-CST-"!"-LEAFTERM| (implies (imf-cst-matchp cst "\"!\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"#"-LEAFTERM| (implies (imf-cst-matchp cst "\"#\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"$"-LEAFTERM| (implies (imf-cst-matchp cst "\"$\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"%"-LEAFTERM| (implies (imf-cst-matchp cst "\"%\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"&"-LEAFTERM| (implies (imf-cst-matchp cst "\"&\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"'"-LEAFTERM| (implies (imf-cst-matchp cst "\"'\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"("-LEAFTERM| (implies (imf-cst-matchp cst "\"(\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-")"-LEAFTERM| (implies (imf-cst-matchp cst "\")\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"*"-LEAFTERM| (implies (imf-cst-matchp cst "\"*\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"+"-LEAFTERM| (implies (imf-cst-matchp cst "\"+\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-","-LEAFTERM| (implies (imf-cst-matchp cst "\",\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"-"-LEAFTERM| (implies (imf-cst-matchp cst "\"-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"."-LEAFTERM| (implies (imf-cst-matchp cst "\".\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"/"-LEAFTERM| (implies (imf-cst-matchp cst "\"/\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-":"-LEAFTERM| (implies (imf-cst-matchp cst "\":\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-";"-LEAFTERM| (implies (imf-cst-matchp cst "\";\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"<"-LEAFTERM| (implies (imf-cst-matchp cst "\"<\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"="-LEAFTERM| (implies (imf-cst-matchp cst "\"=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-">"-LEAFTERM| (implies (imf-cst-matchp cst "\">\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"?"-LEAFTERM| (implies (imf-cst-matchp cst "\"?\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"@"-LEAFTERM| (implies (imf-cst-matchp cst "\"@\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Apr"-LEAFTERM| (implies (imf-cst-matchp cst "\"Apr\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Aug"-LEAFTERM| (implies (imf-cst-matchp cst "\"Aug\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Bcc"-LEAFTERM| (implies (imf-cst-matchp cst "\"Bcc\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Bcc:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Bcc:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"CDT"-LEAFTERM| (implies (imf-cst-matchp cst "\"CDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"CST"-LEAFTERM| (implies (imf-cst-matchp cst "\"CST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Cc"-LEAFTERM| (implies (imf-cst-matchp cst "\"Cc\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Cc:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Cc:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Comments"-LEAFTERM| (implies (imf-cst-matchp cst "\"Comments\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Comments:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Comments:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Date"-LEAFTERM| (implies (imf-cst-matchp cst "\"Date\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Date:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Date:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Dec"-LEAFTERM| (implies (imf-cst-matchp cst "\"Dec\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"EDT"-LEAFTERM| (implies (imf-cst-matchp cst "\"EDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"EST"-LEAFTERM| (implies (imf-cst-matchp cst "\"EST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Feb"-LEAFTERM| (implies (imf-cst-matchp cst "\"Feb\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Fri"-LEAFTERM| (implies (imf-cst-matchp cst "\"Fri\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"From"-LEAFTERM| (implies (imf-cst-matchp cst "\"From\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"From:"-LEAFTERM| (implies (imf-cst-matchp cst "\"From:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"GMT"-LEAFTERM| (implies (imf-cst-matchp cst "\"GMT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"In-Reply-To"-LEAFTERM| (implies (imf-cst-matchp cst "\"In-Reply-To\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"In-Reply-To:"-LEAFTERM| (implies (imf-cst-matchp cst "\"In-Reply-To:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Jan"-LEAFTERM| (implies (imf-cst-matchp cst "\"Jan\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Jul"-LEAFTERM| (implies (imf-cst-matchp cst "\"Jul\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Jun"-LEAFTERM| (implies (imf-cst-matchp cst "\"Jun\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Keywords"-LEAFTERM| (implies (imf-cst-matchp cst "\"Keywords\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Keywords:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Keywords:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"MDT"-LEAFTERM| (implies (imf-cst-matchp cst "\"MDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"MST"-LEAFTERM| (implies (imf-cst-matchp cst "\"MST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Mar"-LEAFTERM| (implies (imf-cst-matchp cst "\"Mar\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"May"-LEAFTERM| (implies (imf-cst-matchp cst "\"May\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Message-ID"-LEAFTERM| (implies (imf-cst-matchp cst "\"Message-ID\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Message-ID:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Message-ID:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Mon"-LEAFTERM| (implies (imf-cst-matchp cst "\"Mon\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Nov"-LEAFTERM| (implies (imf-cst-matchp cst "\"Nov\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Oct"-LEAFTERM| (implies (imf-cst-matchp cst "\"Oct\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"PDT"-LEAFTERM| (implies (imf-cst-matchp cst "\"PDT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"PST"-LEAFTERM| (implies (imf-cst-matchp cst "\"PST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Received"-LEAFTERM| (implies (imf-cst-matchp cst "\"Received\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Received:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Received:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"References"-LEAFTERM| (implies (imf-cst-matchp cst "\"References\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"References:"-LEAFTERM| (implies (imf-cst-matchp cst "\"References:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Reply-To"-LEAFTERM| (implies (imf-cst-matchp cst "\"Reply-To\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Reply-To:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Reply-To:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Bcc"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Bcc\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Bcc:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Bcc:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Cc"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Cc\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Cc:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Cc:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Date"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Date\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Date:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Date:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-From"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-From\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-From:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-From:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Message-ID"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Message-ID\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Message-ID:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Message-ID:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Reply-To"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Reply-To\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Sender"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Sender\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-Sender:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-Sender:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-To"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-To\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Resent-To:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Resent-To:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Return-Path"-LEAFTERM| (implies (imf-cst-matchp cst "\"Return-Path\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Return-Path:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Return-Path:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Sat"-LEAFTERM| (implies (imf-cst-matchp cst "\"Sat\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Sender"-LEAFTERM| (implies (imf-cst-matchp cst "\"Sender\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Sender:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Sender:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Sep"-LEAFTERM| (implies (imf-cst-matchp cst "\"Sep\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Subject"-LEAFTERM| (implies (imf-cst-matchp cst "\"Subject\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Subject:"-LEAFTERM| (implies (imf-cst-matchp cst "\"Subject:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Sun"-LEAFTERM| (implies (imf-cst-matchp cst "\"Sun\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Thu"-LEAFTERM| (implies (imf-cst-matchp cst "\"Thu\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"To"-LEAFTERM| (implies (imf-cst-matchp cst "\"To\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"To:"-LEAFTERM| (implies (imf-cst-matchp cst "\"To:\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Tue"-LEAFTERM| (implies (imf-cst-matchp cst "\"Tue\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"UT"-LEAFTERM| (implies (imf-cst-matchp cst "\"UT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"Wed"-LEAFTERM| (implies (imf-cst-matchp cst "\"Wed\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"["-LEAFTERM| (implies (imf-cst-matchp cst "\"[\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"\\"-LEAFTERM| (implies (imf-cst-matchp cst "\"\\\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"]"-LEAFTERM| (implies (imf-cst-matchp cst "\"]\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"^"-LEAFTERM| (implies (imf-cst-matchp cst "\"^\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"_"-LEAFTERM| (implies (imf-cst-matchp cst "\"_\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"`"-LEAFTERM| (implies (imf-cst-matchp cst "\"`\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"{"-LEAFTERM| (implies (imf-cst-matchp cst "\"{\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"\|"-LEAFTERM| (implies (imf-cst-matchp cst "\"|\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"}"-LEAFTERM| (implies (imf-cst-matchp cst "\"}\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMF-CST-"~"-LEAFTERM| (implies (imf-cst-matchp cst "\"~\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm imf-cst-quoted-pair-nonleaf (implies (imf-cst-matchp cst "quoted-pair") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-fws-nonleaf (implies (imf-cst-matchp cst "fws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-ctext-nonleaf (implies (imf-cst-matchp cst "ctext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-ccontent-nonleaf (implies (imf-cst-matchp cst "ccontent") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-comment-nonleaf (implies (imf-cst-matchp cst "comment") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-cfws-nonleaf (implies (imf-cst-matchp cst "cfws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-atext-nonleaf (implies (imf-cst-matchp cst "atext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-atom-nonleaf (implies (imf-cst-matchp cst "atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-dot-atom-text-nonleaf (implies (imf-cst-matchp cst "dot-atom-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-dot-atom-nonleaf (implies (imf-cst-matchp cst "dot-atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-specials-nonleaf (implies (imf-cst-matchp cst "specials") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-qtext-nonleaf (implies (imf-cst-matchp cst "qtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-qcontent-nonleaf (implies (imf-cst-matchp cst "qcontent") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-quoted-string-nonleaf (implies (imf-cst-matchp cst "quoted-string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-word-nonleaf (implies (imf-cst-matchp cst "word") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-phrase-nonleaf (implies (imf-cst-matchp cst "phrase") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-unstructured-nonleaf (implies (imf-cst-matchp cst "unstructured") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-date-time-nonleaf (implies (imf-cst-matchp cst "date-time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-day-of-week-nonleaf (implies (imf-cst-matchp cst "day-of-week") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-day-name-nonleaf (implies (imf-cst-matchp cst "day-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-date-nonleaf (implies (imf-cst-matchp cst "date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-day-nonleaf (implies (imf-cst-matchp cst "day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-month-nonleaf (implies (imf-cst-matchp cst "month") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-year-nonleaf (implies (imf-cst-matchp cst "year") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-time-nonleaf (implies (imf-cst-matchp cst "time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-time-of-day-nonleaf (implies (imf-cst-matchp cst "time-of-day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-hour-nonleaf (implies (imf-cst-matchp cst "hour") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-minute-nonleaf (implies (imf-cst-matchp cst "minute") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-second-nonleaf (implies (imf-cst-matchp cst "second") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-zone-nonleaf (implies (imf-cst-matchp cst "zone") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-address-nonleaf (implies (imf-cst-matchp cst "address") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-mailbox-nonleaf (implies (imf-cst-matchp cst "mailbox") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-name-addr-nonleaf (implies (imf-cst-matchp cst "name-addr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-angle-addr-nonleaf (implies (imf-cst-matchp cst "angle-addr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-group-nonleaf (implies (imf-cst-matchp cst "group") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-display-name-nonleaf (implies (imf-cst-matchp cst "display-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-mailbox-list-nonleaf (implies (imf-cst-matchp cst "mailbox-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-address-list-nonleaf (implies (imf-cst-matchp cst "address-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-group-list-nonleaf (implies (imf-cst-matchp cst "group-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-addr-spec-nonleaf (implies (imf-cst-matchp cst "addr-spec") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-local-part-nonleaf (implies (imf-cst-matchp cst "local-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-domain-nonleaf (implies (imf-cst-matchp cst "domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-domain-literal-nonleaf (implies (imf-cst-matchp cst "domain-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-dtext-nonleaf (implies (imf-cst-matchp cst "dtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-message-nonleaf (implies (imf-cst-matchp cst "message") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-body-nonleaf (implies (imf-cst-matchp cst "body") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-text-nonleaf (implies (imf-cst-matchp cst "text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-fields-nonleaf (implies (imf-cst-matchp cst "fields") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-orig-date-nonleaf (implies (imf-cst-matchp cst "orig-date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-from-nonleaf (implies (imf-cst-matchp cst "from") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-sender-nonleaf (implies (imf-cst-matchp cst "sender") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-reply-to-nonleaf (implies (imf-cst-matchp cst "reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-to-nonleaf (implies (imf-cst-matchp cst "to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-cc-nonleaf (implies (imf-cst-matchp cst "cc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-bcc-nonleaf (implies (imf-cst-matchp cst "bcc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-message-id-nonleaf (implies (imf-cst-matchp cst "message-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-in-reply-to-nonleaf (implies (imf-cst-matchp cst "in-reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-references-nonleaf (implies (imf-cst-matchp cst "references") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-msg-id-nonleaf (implies (imf-cst-matchp cst "msg-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-id-left-nonleaf (implies (imf-cst-matchp cst "id-left") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-id-right-nonleaf (implies (imf-cst-matchp cst "id-right") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-no-fold-literal-nonleaf (implies (imf-cst-matchp cst "no-fold-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-subject-nonleaf (implies (imf-cst-matchp cst "subject") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-comments-nonleaf (implies (imf-cst-matchp cst "comments") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-keywords-nonleaf (implies (imf-cst-matchp cst "keywords") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-date-nonleaf (implies (imf-cst-matchp cst "resent-date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-from-nonleaf (implies (imf-cst-matchp cst "resent-from") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-sender-nonleaf (implies (imf-cst-matchp cst "resent-sender") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-to-nonleaf (implies (imf-cst-matchp cst "resent-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-cc-nonleaf (implies (imf-cst-matchp cst "resent-cc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-bcc-nonleaf (implies (imf-cst-matchp cst "resent-bcc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-resent-msg-id-nonleaf (implies (imf-cst-matchp cst "resent-msg-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-trace-nonleaf (implies (imf-cst-matchp cst "trace") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-return-nonleaf (implies (imf-cst-matchp cst "return") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-path-nonleaf (implies (imf-cst-matchp cst "path") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-received-nonleaf (implies (imf-cst-matchp cst "received") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-received-token-nonleaf (implies (imf-cst-matchp cst "received-token") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-optional-field-nonleaf (implies (imf-cst-matchp cst "optional-field") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-field-name-nonleaf (implies (imf-cst-matchp cst "field-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-ftext-nonleaf (implies (imf-cst-matchp cst "ftext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-nonleaf (implies (imf-cst-matchp cst "obs-no-ws-ctl") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-ctext-nonleaf (implies (imf-cst-matchp cst "obs-ctext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-qtext-nonleaf (implies (imf-cst-matchp cst "obs-qtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-utext-nonleaf (implies (imf-cst-matchp cst "obs-utext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-qp-nonleaf (implies (imf-cst-matchp cst "obs-qp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-body-nonleaf (implies (imf-cst-matchp cst "obs-body") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-unstruct-nonleaf (implies (imf-cst-matchp cst "obs-unstruct") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-phrase-nonleaf (implies (imf-cst-matchp cst "obs-phrase") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-phrase-list-nonleaf (implies (imf-cst-matchp cst "obs-phrase-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-fws-nonleaf (implies (imf-cst-matchp cst "obs-fws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-day-of-week-nonleaf (implies (imf-cst-matchp cst "obs-day-of-week") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-day-nonleaf (implies (imf-cst-matchp cst "obs-day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-year-nonleaf (implies (imf-cst-matchp cst "obs-year") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-hour-nonleaf (implies (imf-cst-matchp cst "obs-hour") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-minute-nonleaf (implies (imf-cst-matchp cst "obs-minute") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-second-nonleaf (implies (imf-cst-matchp cst "obs-second") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-zone-nonleaf (implies (imf-cst-matchp cst "obs-zone") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-angle-addr-nonleaf (implies (imf-cst-matchp cst "obs-angle-addr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-route-nonleaf (implies (imf-cst-matchp cst "obs-route") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-domain-list-nonleaf (implies (imf-cst-matchp cst "obs-domain-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-mbox-list-nonleaf (implies (imf-cst-matchp cst "obs-mbox-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-addr-list-nonleaf (implies (imf-cst-matchp cst "obs-addr-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-group-list-nonleaf (implies (imf-cst-matchp cst "obs-group-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-local-part-nonleaf (implies (imf-cst-matchp cst "obs-local-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-domain-nonleaf (implies (imf-cst-matchp cst "obs-domain") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-dtext-nonleaf (implies (imf-cst-matchp cst "obs-dtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-fields-nonleaf (implies (imf-cst-matchp cst "obs-fields") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-orig-date-nonleaf (implies (imf-cst-matchp cst "obs-orig-date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-from-nonleaf (implies (imf-cst-matchp cst "obs-from") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-sender-nonleaf (implies (imf-cst-matchp cst "obs-sender") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-reply-to-nonleaf (implies (imf-cst-matchp cst "obs-reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-to-nonleaf (implies (imf-cst-matchp cst "obs-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-cc-nonleaf (implies (imf-cst-matchp cst "obs-cc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-bcc-nonleaf (implies (imf-cst-matchp cst "obs-bcc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-message-id-nonleaf (implies (imf-cst-matchp cst "obs-message-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-in-reply-to-nonleaf (implies (imf-cst-matchp cst "obs-in-reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-references-nonleaf (implies (imf-cst-matchp cst "obs-references") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-id-left-nonleaf (implies (imf-cst-matchp cst "obs-id-left") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-id-right-nonleaf (implies (imf-cst-matchp cst "obs-id-right") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-subject-nonleaf (implies (imf-cst-matchp cst "obs-subject") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-comments-nonleaf (implies (imf-cst-matchp cst "obs-comments") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-keywords-nonleaf (implies (imf-cst-matchp cst "obs-keywords") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-from-nonleaf (implies (imf-cst-matchp cst "obs-resent-from") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-send-nonleaf (implies (imf-cst-matchp cst "obs-resent-send") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-date-nonleaf (implies (imf-cst-matchp cst "obs-resent-date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-to-nonleaf (implies (imf-cst-matchp cst "obs-resent-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-cc-nonleaf (implies (imf-cst-matchp cst "obs-resent-cc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-bcc-nonleaf (implies (imf-cst-matchp cst "obs-resent-bcc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-mid-nonleaf (implies (imf-cst-matchp cst "obs-resent-mid") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-resent-rply-nonleaf (implies (imf-cst-matchp cst "obs-resent-rply") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-return-nonleaf (implies (imf-cst-matchp cst "obs-return") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-received-nonleaf (implies (imf-cst-matchp cst "obs-received") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-obs-optional-nonleaf (implies (imf-cst-matchp cst "obs-optional") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-alpha-nonleaf (implies (imf-cst-matchp cst "alpha") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-cr-nonleaf (implies (imf-cst-matchp cst "cr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-crlf-nonleaf (implies (imf-cst-matchp cst "crlf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-digit-nonleaf (implies (imf-cst-matchp cst "digit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-dquote-nonleaf (implies (imf-cst-matchp cst "dquote") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-lf-nonleaf (implies (imf-cst-matchp cst "lf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-vchar-nonleaf (implies (imf-cst-matchp cst "vchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-wsp-nonleaf (implies (imf-cst-matchp cst "wsp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-htab-nonleaf (implies (imf-cst-matchp cst "htab") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-sp-nonleaf (implies (imf-cst-matchp cst "sp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imf-cst-quoted-pair-rulename (implies (imf-cst-matchp cst "quoted-pair") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-pair"))))
Theorem:
(defthm imf-cst-fws-rulename (implies (imf-cst-matchp cst "fws") (equal (tree-nonleaf->rulename? cst) (rulename "fws"))))
Theorem:
(defthm imf-cst-ctext-rulename (implies (imf-cst-matchp cst "ctext") (equal (tree-nonleaf->rulename? cst) (rulename "ctext"))))
Theorem:
(defthm imf-cst-ccontent-rulename (implies (imf-cst-matchp cst "ccontent") (equal (tree-nonleaf->rulename? cst) (rulename "ccontent"))))
Theorem:
(defthm imf-cst-comment-rulename (implies (imf-cst-matchp cst "comment") (equal (tree-nonleaf->rulename? cst) (rulename "comment"))))
Theorem:
(defthm imf-cst-cfws-rulename (implies (imf-cst-matchp cst "cfws") (equal (tree-nonleaf->rulename? cst) (rulename "cfws"))))
Theorem:
(defthm imf-cst-atext-rulename (implies (imf-cst-matchp cst "atext") (equal (tree-nonleaf->rulename? cst) (rulename "atext"))))
Theorem:
(defthm imf-cst-atom-rulename (implies (imf-cst-matchp cst "atom") (equal (tree-nonleaf->rulename? cst) (rulename "atom"))))
Theorem:
(defthm imf-cst-dot-atom-text-rulename (implies (imf-cst-matchp cst "dot-atom-text") (equal (tree-nonleaf->rulename? cst) (rulename "dot-atom-text"))))
Theorem:
(defthm imf-cst-dot-atom-rulename (implies (imf-cst-matchp cst "dot-atom") (equal (tree-nonleaf->rulename? cst) (rulename "dot-atom"))))
Theorem:
(defthm imf-cst-specials-rulename (implies (imf-cst-matchp cst "specials") (equal (tree-nonleaf->rulename? cst) (rulename "specials"))))
Theorem:
(defthm imf-cst-qtext-rulename (implies (imf-cst-matchp cst "qtext") (equal (tree-nonleaf->rulename? cst) (rulename "qtext"))))
Theorem:
(defthm imf-cst-qcontent-rulename (implies (imf-cst-matchp cst "qcontent") (equal (tree-nonleaf->rulename? cst) (rulename "qcontent"))))
Theorem:
(defthm imf-cst-quoted-string-rulename (implies (imf-cst-matchp cst "quoted-string") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-string"))))
Theorem:
(defthm imf-cst-word-rulename (implies (imf-cst-matchp cst "word") (equal (tree-nonleaf->rulename? cst) (rulename "word"))))
Theorem:
(defthm imf-cst-phrase-rulename (implies (imf-cst-matchp cst "phrase") (equal (tree-nonleaf->rulename? cst) (rulename "phrase"))))
Theorem:
(defthm imf-cst-unstructured-rulename (implies (imf-cst-matchp cst "unstructured") (equal (tree-nonleaf->rulename? cst) (rulename "unstructured"))))
Theorem:
(defthm imf-cst-date-time-rulename (implies (imf-cst-matchp cst "date-time") (equal (tree-nonleaf->rulename? cst) (rulename "date-time"))))
Theorem:
(defthm imf-cst-day-of-week-rulename (implies (imf-cst-matchp cst "day-of-week") (equal (tree-nonleaf->rulename? cst) (rulename "day-of-week"))))
Theorem:
(defthm imf-cst-day-name-rulename (implies (imf-cst-matchp cst "day-name") (equal (tree-nonleaf->rulename? cst) (rulename "day-name"))))
Theorem:
(defthm imf-cst-date-rulename (implies (imf-cst-matchp cst "date") (equal (tree-nonleaf->rulename? cst) (rulename "date"))))
Theorem:
(defthm imf-cst-day-rulename (implies (imf-cst-matchp cst "day") (equal (tree-nonleaf->rulename? cst) (rulename "day"))))
Theorem:
(defthm imf-cst-month-rulename (implies (imf-cst-matchp cst "month") (equal (tree-nonleaf->rulename? cst) (rulename "month"))))
Theorem:
(defthm imf-cst-year-rulename (implies (imf-cst-matchp cst "year") (equal (tree-nonleaf->rulename? cst) (rulename "year"))))
Theorem:
(defthm imf-cst-time-rulename (implies (imf-cst-matchp cst "time") (equal (tree-nonleaf->rulename? cst) (rulename "time"))))
Theorem:
(defthm imf-cst-time-of-day-rulename (implies (imf-cst-matchp cst "time-of-day") (equal (tree-nonleaf->rulename? cst) (rulename "time-of-day"))))
Theorem:
(defthm imf-cst-hour-rulename (implies (imf-cst-matchp cst "hour") (equal (tree-nonleaf->rulename? cst) (rulename "hour"))))
Theorem:
(defthm imf-cst-minute-rulename (implies (imf-cst-matchp cst "minute") (equal (tree-nonleaf->rulename? cst) (rulename "minute"))))
Theorem:
(defthm imf-cst-second-rulename (implies (imf-cst-matchp cst "second") (equal (tree-nonleaf->rulename? cst) (rulename "second"))))
Theorem:
(defthm imf-cst-zone-rulename (implies (imf-cst-matchp cst "zone") (equal (tree-nonleaf->rulename? cst) (rulename "zone"))))
Theorem:
(defthm imf-cst-address-rulename (implies (imf-cst-matchp cst "address") (equal (tree-nonleaf->rulename? cst) (rulename "address"))))
Theorem:
(defthm imf-cst-mailbox-rulename (implies (imf-cst-matchp cst "mailbox") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox"))))
Theorem:
(defthm imf-cst-name-addr-rulename (implies (imf-cst-matchp cst "name-addr") (equal (tree-nonleaf->rulename? cst) (rulename "name-addr"))))
Theorem:
(defthm imf-cst-angle-addr-rulename (implies (imf-cst-matchp cst "angle-addr") (equal (tree-nonleaf->rulename? cst) (rulename "angle-addr"))))
Theorem:
(defthm imf-cst-group-rulename (implies (imf-cst-matchp cst "group") (equal (tree-nonleaf->rulename? cst) (rulename "group"))))
Theorem:
(defthm imf-cst-display-name-rulename (implies (imf-cst-matchp cst "display-name") (equal (tree-nonleaf->rulename? cst) (rulename "display-name"))))
Theorem:
(defthm imf-cst-mailbox-list-rulename (implies (imf-cst-matchp cst "mailbox-list") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox-list"))))
Theorem:
(defthm imf-cst-address-list-rulename (implies (imf-cst-matchp cst "address-list") (equal (tree-nonleaf->rulename? cst) (rulename "address-list"))))
Theorem:
(defthm imf-cst-group-list-rulename (implies (imf-cst-matchp cst "group-list") (equal (tree-nonleaf->rulename? cst) (rulename "group-list"))))
Theorem:
(defthm imf-cst-addr-spec-rulename (implies (imf-cst-matchp cst "addr-spec") (equal (tree-nonleaf->rulename? cst) (rulename "addr-spec"))))
Theorem:
(defthm imf-cst-local-part-rulename (implies (imf-cst-matchp cst "local-part") (equal (tree-nonleaf->rulename? cst) (rulename "local-part"))))
Theorem:
(defthm imf-cst-domain-rulename (implies (imf-cst-matchp cst "domain") (equal (tree-nonleaf->rulename? cst) (rulename "domain"))))
Theorem:
(defthm imf-cst-domain-literal-rulename (implies (imf-cst-matchp cst "domain-literal") (equal (tree-nonleaf->rulename? cst) (rulename "domain-literal"))))
Theorem:
(defthm imf-cst-dtext-rulename (implies (imf-cst-matchp cst "dtext") (equal (tree-nonleaf->rulename? cst) (rulename "dtext"))))
Theorem:
(defthm imf-cst-message-rulename (implies (imf-cst-matchp cst "message") (equal (tree-nonleaf->rulename? cst) (rulename "message"))))
Theorem:
(defthm imf-cst-body-rulename (implies (imf-cst-matchp cst "body") (equal (tree-nonleaf->rulename? cst) (rulename "body"))))
Theorem:
(defthm imf-cst-text-rulename (implies (imf-cst-matchp cst "text") (equal (tree-nonleaf->rulename? cst) (rulename "text"))))
Theorem:
(defthm imf-cst-fields-rulename (implies (imf-cst-matchp cst "fields") (equal (tree-nonleaf->rulename? cst) (rulename "fields"))))
Theorem:
(defthm imf-cst-orig-date-rulename (implies (imf-cst-matchp cst "orig-date") (equal (tree-nonleaf->rulename? cst) (rulename "orig-date"))))
Theorem:
(defthm imf-cst-from-rulename (implies (imf-cst-matchp cst "from") (equal (tree-nonleaf->rulename? cst) (rulename "from"))))
Theorem:
(defthm imf-cst-sender-rulename (implies (imf-cst-matchp cst "sender") (equal (tree-nonleaf->rulename? cst) (rulename "sender"))))
Theorem:
(defthm imf-cst-reply-to-rulename (implies (imf-cst-matchp cst "reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "reply-to"))))
Theorem:
(defthm imf-cst-to-rulename (implies (imf-cst-matchp cst "to") (equal (tree-nonleaf->rulename? cst) (rulename "to"))))
Theorem:
(defthm imf-cst-cc-rulename (implies (imf-cst-matchp cst "cc") (equal (tree-nonleaf->rulename? cst) (rulename "cc"))))
Theorem:
(defthm imf-cst-bcc-rulename (implies (imf-cst-matchp cst "bcc") (equal (tree-nonleaf->rulename? cst) (rulename "bcc"))))
Theorem:
(defthm imf-cst-message-id-rulename (implies (imf-cst-matchp cst "message-id") (equal (tree-nonleaf->rulename? cst) (rulename "message-id"))))
Theorem:
(defthm imf-cst-in-reply-to-rulename (implies (imf-cst-matchp cst "in-reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "in-reply-to"))))
Theorem:
(defthm imf-cst-references-rulename (implies (imf-cst-matchp cst "references") (equal (tree-nonleaf->rulename? cst) (rulename "references"))))
Theorem:
(defthm imf-cst-msg-id-rulename (implies (imf-cst-matchp cst "msg-id") (equal (tree-nonleaf->rulename? cst) (rulename "msg-id"))))
Theorem:
(defthm imf-cst-id-left-rulename (implies (imf-cst-matchp cst "id-left") (equal (tree-nonleaf->rulename? cst) (rulename "id-left"))))
Theorem:
(defthm imf-cst-id-right-rulename (implies (imf-cst-matchp cst "id-right") (equal (tree-nonleaf->rulename? cst) (rulename "id-right"))))
Theorem:
(defthm imf-cst-no-fold-literal-rulename (implies (imf-cst-matchp cst "no-fold-literal") (equal (tree-nonleaf->rulename? cst) (rulename "no-fold-literal"))))
Theorem:
(defthm imf-cst-subject-rulename (implies (imf-cst-matchp cst "subject") (equal (tree-nonleaf->rulename? cst) (rulename "subject"))))
Theorem:
(defthm imf-cst-comments-rulename (implies (imf-cst-matchp cst "comments") (equal (tree-nonleaf->rulename? cst) (rulename "comments"))))
Theorem:
(defthm imf-cst-keywords-rulename (implies (imf-cst-matchp cst "keywords") (equal (tree-nonleaf->rulename? cst) (rulename "keywords"))))
Theorem:
(defthm imf-cst-resent-date-rulename (implies (imf-cst-matchp cst "resent-date") (equal (tree-nonleaf->rulename? cst) (rulename "resent-date"))))
Theorem:
(defthm imf-cst-resent-from-rulename (implies (imf-cst-matchp cst "resent-from") (equal (tree-nonleaf->rulename? cst) (rulename "resent-from"))))
Theorem:
(defthm imf-cst-resent-sender-rulename (implies (imf-cst-matchp cst "resent-sender") (equal (tree-nonleaf->rulename? cst) (rulename "resent-sender"))))
Theorem:
(defthm imf-cst-resent-to-rulename (implies (imf-cst-matchp cst "resent-to") (equal (tree-nonleaf->rulename? cst) (rulename "resent-to"))))
Theorem:
(defthm imf-cst-resent-cc-rulename (implies (imf-cst-matchp cst "resent-cc") (equal (tree-nonleaf->rulename? cst) (rulename "resent-cc"))))
Theorem:
(defthm imf-cst-resent-bcc-rulename (implies (imf-cst-matchp cst "resent-bcc") (equal (tree-nonleaf->rulename? cst) (rulename "resent-bcc"))))
Theorem:
(defthm imf-cst-resent-msg-id-rulename (implies (imf-cst-matchp cst "resent-msg-id") (equal (tree-nonleaf->rulename? cst) (rulename "resent-msg-id"))))
Theorem:
(defthm imf-cst-trace-rulename (implies (imf-cst-matchp cst "trace") (equal (tree-nonleaf->rulename? cst) (rulename "trace"))))
Theorem:
(defthm imf-cst-return-rulename (implies (imf-cst-matchp cst "return") (equal (tree-nonleaf->rulename? cst) (rulename "return"))))
Theorem:
(defthm imf-cst-path-rulename (implies (imf-cst-matchp cst "path") (equal (tree-nonleaf->rulename? cst) (rulename "path"))))
Theorem:
(defthm imf-cst-received-rulename (implies (imf-cst-matchp cst "received") (equal (tree-nonleaf->rulename? cst) (rulename "received"))))
Theorem:
(defthm imf-cst-received-token-rulename (implies (imf-cst-matchp cst "received-token") (equal (tree-nonleaf->rulename? cst) (rulename "received-token"))))
Theorem:
(defthm imf-cst-optional-field-rulename (implies (imf-cst-matchp cst "optional-field") (equal (tree-nonleaf->rulename? cst) (rulename "optional-field"))))
Theorem:
(defthm imf-cst-field-name-rulename (implies (imf-cst-matchp cst "field-name") (equal (tree-nonleaf->rulename? cst) (rulename "field-name"))))
Theorem:
(defthm imf-cst-ftext-rulename (implies (imf-cst-matchp cst "ftext") (equal (tree-nonleaf->rulename? cst) (rulename "ftext"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-rulename (implies (imf-cst-matchp cst "obs-no-ws-ctl") (equal (tree-nonleaf->rulename? cst) (rulename "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-ctext-rulename (implies (imf-cst-matchp cst "obs-ctext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-ctext"))))
Theorem:
(defthm imf-cst-obs-qtext-rulename (implies (imf-cst-matchp cst "obs-qtext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-qtext"))))
Theorem:
(defthm imf-cst-obs-utext-rulename (implies (imf-cst-matchp cst "obs-utext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-utext"))))
Theorem:
(defthm imf-cst-obs-qp-rulename (implies (imf-cst-matchp cst "obs-qp") (equal (tree-nonleaf->rulename? cst) (rulename "obs-qp"))))
Theorem:
(defthm imf-cst-obs-body-rulename (implies (imf-cst-matchp cst "obs-body") (equal (tree-nonleaf->rulename? cst) (rulename "obs-body"))))
Theorem:
(defthm imf-cst-obs-unstruct-rulename (implies (imf-cst-matchp cst "obs-unstruct") (equal (tree-nonleaf->rulename? cst) (rulename "obs-unstruct"))))
Theorem:
(defthm imf-cst-obs-phrase-rulename (implies (imf-cst-matchp cst "obs-phrase") (equal (tree-nonleaf->rulename? cst) (rulename "obs-phrase"))))
Theorem:
(defthm imf-cst-obs-phrase-list-rulename (implies (imf-cst-matchp cst "obs-phrase-list") (equal (tree-nonleaf->rulename? cst) (rulename "obs-phrase-list"))))
Theorem:
(defthm imf-cst-obs-fws-rulename (implies (imf-cst-matchp cst "obs-fws") (equal (tree-nonleaf->rulename? cst) (rulename "obs-fws"))))
Theorem:
(defthm imf-cst-obs-day-of-week-rulename (implies (imf-cst-matchp cst "obs-day-of-week") (equal (tree-nonleaf->rulename? cst) (rulename "obs-day-of-week"))))
Theorem:
(defthm imf-cst-obs-day-rulename (implies (imf-cst-matchp cst "obs-day") (equal (tree-nonleaf->rulename? cst) (rulename "obs-day"))))
Theorem:
(defthm imf-cst-obs-year-rulename (implies (imf-cst-matchp cst "obs-year") (equal (tree-nonleaf->rulename? cst) (rulename "obs-year"))))
Theorem:
(defthm imf-cst-obs-hour-rulename (implies (imf-cst-matchp cst "obs-hour") (equal (tree-nonleaf->rulename? cst) (rulename "obs-hour"))))
Theorem:
(defthm imf-cst-obs-minute-rulename (implies (imf-cst-matchp cst "obs-minute") (equal (tree-nonleaf->rulename? cst) (rulename "obs-minute"))))
Theorem:
(defthm imf-cst-obs-second-rulename (implies (imf-cst-matchp cst "obs-second") (equal (tree-nonleaf->rulename? cst) (rulename "obs-second"))))
Theorem:
(defthm imf-cst-obs-zone-rulename (implies (imf-cst-matchp cst "obs-zone") (equal (tree-nonleaf->rulename? cst) (rulename "obs-zone"))))
Theorem:
(defthm imf-cst-obs-angle-addr-rulename (implies (imf-cst-matchp cst "obs-angle-addr") (equal (tree-nonleaf->rulename? cst) (rulename "obs-angle-addr"))))
Theorem:
(defthm imf-cst-obs-route-rulename (implies (imf-cst-matchp cst "obs-route") (equal (tree-nonleaf->rulename? cst) (rulename "obs-route"))))
Theorem:
(defthm imf-cst-obs-domain-list-rulename (implies (imf-cst-matchp cst "obs-domain-list") (equal (tree-nonleaf->rulename? cst) (rulename "obs-domain-list"))))
Theorem:
(defthm imf-cst-obs-mbox-list-rulename (implies (imf-cst-matchp cst "obs-mbox-list") (equal (tree-nonleaf->rulename? cst) (rulename "obs-mbox-list"))))
Theorem:
(defthm imf-cst-obs-addr-list-rulename (implies (imf-cst-matchp cst "obs-addr-list") (equal (tree-nonleaf->rulename? cst) (rulename "obs-addr-list"))))
Theorem:
(defthm imf-cst-obs-group-list-rulename (implies (imf-cst-matchp cst "obs-group-list") (equal (tree-nonleaf->rulename? cst) (rulename "obs-group-list"))))
Theorem:
(defthm imf-cst-obs-local-part-rulename (implies (imf-cst-matchp cst "obs-local-part") (equal (tree-nonleaf->rulename? cst) (rulename "obs-local-part"))))
Theorem:
(defthm imf-cst-obs-domain-rulename (implies (imf-cst-matchp cst "obs-domain") (equal (tree-nonleaf->rulename? cst) (rulename "obs-domain"))))
Theorem:
(defthm imf-cst-obs-dtext-rulename (implies (imf-cst-matchp cst "obs-dtext") (equal (tree-nonleaf->rulename? cst) (rulename "obs-dtext"))))
Theorem:
(defthm imf-cst-obs-fields-rulename (implies (imf-cst-matchp cst "obs-fields") (equal (tree-nonleaf->rulename? cst) (rulename "obs-fields"))))
Theorem:
(defthm imf-cst-obs-orig-date-rulename (implies (imf-cst-matchp cst "obs-orig-date") (equal (tree-nonleaf->rulename? cst) (rulename "obs-orig-date"))))
Theorem:
(defthm imf-cst-obs-from-rulename (implies (imf-cst-matchp cst "obs-from") (equal (tree-nonleaf->rulename? cst) (rulename "obs-from"))))
Theorem:
(defthm imf-cst-obs-sender-rulename (implies (imf-cst-matchp cst "obs-sender") (equal (tree-nonleaf->rulename? cst) (rulename "obs-sender"))))
Theorem:
(defthm imf-cst-obs-reply-to-rulename (implies (imf-cst-matchp cst "obs-reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "obs-reply-to"))))
Theorem:
(defthm imf-cst-obs-to-rulename (implies (imf-cst-matchp cst "obs-to") (equal (tree-nonleaf->rulename? cst) (rulename "obs-to"))))
Theorem:
(defthm imf-cst-obs-cc-rulename (implies (imf-cst-matchp cst "obs-cc") (equal (tree-nonleaf->rulename? cst) (rulename "obs-cc"))))
Theorem:
(defthm imf-cst-obs-bcc-rulename (implies (imf-cst-matchp cst "obs-bcc") (equal (tree-nonleaf->rulename? cst) (rulename "obs-bcc"))))
Theorem:
(defthm imf-cst-obs-message-id-rulename (implies (imf-cst-matchp cst "obs-message-id") (equal (tree-nonleaf->rulename? cst) (rulename "obs-message-id"))))
Theorem:
(defthm imf-cst-obs-in-reply-to-rulename (implies (imf-cst-matchp cst "obs-in-reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "obs-in-reply-to"))))
Theorem:
(defthm imf-cst-obs-references-rulename (implies (imf-cst-matchp cst "obs-references") (equal (tree-nonleaf->rulename? cst) (rulename "obs-references"))))
Theorem:
(defthm imf-cst-obs-id-left-rulename (implies (imf-cst-matchp cst "obs-id-left") (equal (tree-nonleaf->rulename? cst) (rulename "obs-id-left"))))
Theorem:
(defthm imf-cst-obs-id-right-rulename (implies (imf-cst-matchp cst "obs-id-right") (equal (tree-nonleaf->rulename? cst) (rulename "obs-id-right"))))
Theorem:
(defthm imf-cst-obs-subject-rulename (implies (imf-cst-matchp cst "obs-subject") (equal (tree-nonleaf->rulename? cst) (rulename "obs-subject"))))
Theorem:
(defthm imf-cst-obs-comments-rulename (implies (imf-cst-matchp cst "obs-comments") (equal (tree-nonleaf->rulename? cst) (rulename "obs-comments"))))
Theorem:
(defthm imf-cst-obs-keywords-rulename (implies (imf-cst-matchp cst "obs-keywords") (equal (tree-nonleaf->rulename? cst) (rulename "obs-keywords"))))
Theorem:
(defthm imf-cst-obs-resent-from-rulename (implies (imf-cst-matchp cst "obs-resent-from") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-from"))))
Theorem:
(defthm imf-cst-obs-resent-send-rulename (implies (imf-cst-matchp cst "obs-resent-send") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-send"))))
Theorem:
(defthm imf-cst-obs-resent-date-rulename (implies (imf-cst-matchp cst "obs-resent-date") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-date"))))
Theorem:
(defthm imf-cst-obs-resent-to-rulename (implies (imf-cst-matchp cst "obs-resent-to") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-to"))))
Theorem:
(defthm imf-cst-obs-resent-cc-rulename (implies (imf-cst-matchp cst "obs-resent-cc") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-cc"))))
Theorem:
(defthm imf-cst-obs-resent-bcc-rulename (implies (imf-cst-matchp cst "obs-resent-bcc") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-bcc"))))
Theorem:
(defthm imf-cst-obs-resent-mid-rulename (implies (imf-cst-matchp cst "obs-resent-mid") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-mid"))))
Theorem:
(defthm imf-cst-obs-resent-rply-rulename (implies (imf-cst-matchp cst "obs-resent-rply") (equal (tree-nonleaf->rulename? cst) (rulename "obs-resent-rply"))))
Theorem:
(defthm imf-cst-obs-return-rulename (implies (imf-cst-matchp cst "obs-return") (equal (tree-nonleaf->rulename? cst) (rulename "obs-return"))))
Theorem:
(defthm imf-cst-obs-received-rulename (implies (imf-cst-matchp cst "obs-received") (equal (tree-nonleaf->rulename? cst) (rulename "obs-received"))))
Theorem:
(defthm imf-cst-obs-optional-rulename (implies (imf-cst-matchp cst "obs-optional") (equal (tree-nonleaf->rulename? cst) (rulename "obs-optional"))))
Theorem:
(defthm imf-cst-alpha-rulename (implies (imf-cst-matchp cst "alpha") (equal (tree-nonleaf->rulename? cst) (rulename "alpha"))))
Theorem:
(defthm imf-cst-cr-rulename (implies (imf-cst-matchp cst "cr") (equal (tree-nonleaf->rulename? cst) (rulename "cr"))))
Theorem:
(defthm imf-cst-crlf-rulename (implies (imf-cst-matchp cst "crlf") (equal (tree-nonleaf->rulename? cst) (rulename "crlf"))))
Theorem:
(defthm imf-cst-digit-rulename (implies (imf-cst-matchp cst "digit") (equal (tree-nonleaf->rulename? cst) (rulename "digit"))))
Theorem:
(defthm imf-cst-dquote-rulename (implies (imf-cst-matchp cst "dquote") (equal (tree-nonleaf->rulename? cst) (rulename "dquote"))))
Theorem:
(defthm imf-cst-lf-rulename (implies (imf-cst-matchp cst "lf") (equal (tree-nonleaf->rulename? cst) (rulename "lf"))))
Theorem:
(defthm imf-cst-vchar-rulename (implies (imf-cst-matchp cst "vchar") (equal (tree-nonleaf->rulename? cst) (rulename "vchar"))))
Theorem:
(defthm imf-cst-wsp-rulename (implies (imf-cst-matchp cst "wsp") (equal (tree-nonleaf->rulename? cst) (rulename "wsp"))))
Theorem:
(defthm imf-cst-htab-rulename (implies (imf-cst-matchp cst "htab") (equal (tree-nonleaf->rulename? cst) (rulename "htab"))))
Theorem:
(defthm imf-cst-sp-rulename (implies (imf-cst-matchp cst "sp") (equal (tree-nonleaf->rulename? cst) (rulename "sp"))))
Theorem:
(defthm imf-cst-quoted-pair-branches-match-alt (implies (imf-cst-matchp cst "quoted-pair") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"\\\" ( vchar / wsp ) ) / obs-qp")))
Theorem:
(defthm imf-cst-fws-branches-match-alt (implies (imf-cst-matchp cst "fws") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ *wsp crlf ] 1*wsp ) / obs-fws")))
Theorem:
(defthm imf-cst-ctext-branches-match-alt (implies (imf-cst-matchp cst "ctext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-39 / %d42-91 / %d93-126 / obs-ctext")))
Theorem:
(defthm imf-cst-ccontent-branches-match-alt (implies (imf-cst-matchp cst "ccontent") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ctext / quoted-pair / comment")))
Theorem:
(defthm imf-cst-comment-branches-match-alt (implies (imf-cst-matchp cst "comment") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"")))
Theorem:
(defthm imf-cst-cfws-branches-match-alt (implies (imf-cst-matchp cst "cfws") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( 1*( [ fws ] comment ) [ fws ] ) / fws")))
Theorem:
(defthm imf-cst-atext-branches-match-alt (implies (imf-cst-matchp cst "atext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"")))
Theorem:
(defthm imf-cst-atom-branches-match-alt (implies (imf-cst-matchp cst "atom") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 1*atext [ cfws ]")))
Theorem:
(defthm imf-cst-dot-atom-text-branches-match-alt (implies (imf-cst-matchp cst "dot-atom-text") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*atext *( \".\" 1*atext )")))
Theorem:
(defthm imf-cst-dot-atom-branches-match-alt (implies (imf-cst-matchp cst "dot-atom") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] dot-atom-text [ cfws ]")))
Theorem:
(defthm imf-cst-specials-branches-match-alt (implies (imf-cst-matchp cst "specials") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" / \")\" / \"<\" / \">\" / \"[\" / \"]\" / \":\" / \";\" / \"@\" / \"\\\" / \",\" / \".\" / dquote")))
Theorem:
(defthm imf-cst-qtext-branches-match-alt (implies (imf-cst-matchp cst "qtext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33 / %d35-91 / %d93-126 / obs-qtext")))
Theorem:
(defthm imf-cst-qcontent-branches-match-alt (implies (imf-cst-matchp cst "qcontent") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "qtext / quoted-pair")))
Theorem:
(defthm imf-cst-quoted-string-branches-match-alt (implies (imf-cst-matchp cst "quoted-string") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]")))
Theorem:
(defthm imf-cst-word-branches-match-alt (implies (imf-cst-matchp cst "word") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom / quoted-string")))
Theorem:
(defthm imf-cst-phrase-branches-match-alt (implies (imf-cst-matchp cst "phrase") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*word / obs-phrase")))
Theorem:
(defthm imf-cst-unstructured-branches-match-alt (implies (imf-cst-matchp cst "unstructured") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( *( [ fws ] vchar ) *wsp ) / obs-unstruct")))
Theorem:
(defthm imf-cst-date-time-branches-match-alt (implies (imf-cst-matchp cst "date-time") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ day-of-week \",\" ] date time [ cfws ]")))
Theorem:
(defthm imf-cst-day-of-week-branches-match-alt (implies (imf-cst-matchp cst "day-of-week") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ fws ] day-name ) / obs-day-of-week")))
Theorem:
(defthm imf-cst-day-name-branches-match-alt (implies (imf-cst-matchp cst "day-name") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"")))
Theorem:
(defthm imf-cst-date-branches-match-alt (implies (imf-cst-matchp cst "date") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "day month year")))
Theorem:
(defthm imf-cst-day-branches-match-alt (implies (imf-cst-matchp cst "day") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ fws ] 1*2digit fws ) / obs-day")))
Theorem:
(defthm imf-cst-month-branches-match-alt (implies (imf-cst-matchp cst "month") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"")))
Theorem:
(defthm imf-cst-year-branches-match-alt (implies (imf-cst-matchp cst "year") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( fws 4*digit fws ) / obs-year")))
Theorem:
(defthm imf-cst-time-branches-match-alt (implies (imf-cst-matchp cst "time") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "time-of-day zone")))
Theorem:
(defthm imf-cst-time-of-day-branches-match-alt (implies (imf-cst-matchp cst "time-of-day") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "hour \":\" minute [ \":\" second ]")))
Theorem:
(defthm imf-cst-hour-branches-match-alt (implies (imf-cst-matchp cst "hour") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-hour")))
Theorem:
(defthm imf-cst-minute-branches-match-alt (implies (imf-cst-matchp cst "minute") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-minute")))
Theorem:
(defthm imf-cst-second-branches-match-alt (implies (imf-cst-matchp cst "second") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit / obs-second")))
Theorem:
(defthm imf-cst-zone-branches-match-alt (implies (imf-cst-matchp cst "zone") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone")))
Theorem:
(defthm imf-cst-address-branches-match-alt (implies (imf-cst-matchp cst "address") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "mailbox / group")))
Theorem:
(defthm imf-cst-mailbox-branches-match-alt (implies (imf-cst-matchp cst "mailbox") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "name-addr / addr-spec")))
Theorem:
(defthm imf-cst-name-addr-branches-match-alt (implies (imf-cst-matchp cst "name-addr") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ display-name ] angle-addr")))
Theorem:
(defthm imf-cst-angle-addr-branches-match-alt (implies (imf-cst-matchp cst "angle-addr") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"<\" addr-spec \">\" [ cfws ] / obs-angle-addr")))
Theorem:
(defthm imf-cst-group-branches-match-alt (implies (imf-cst-matchp cst "group") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "display-name \":\" [ group-list ] \";\" [ cfws ]")))
Theorem:
(defthm imf-cst-display-name-branches-match-alt (implies (imf-cst-matchp cst "display-name") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "phrase")))
Theorem:
(defthm imf-cst-mailbox-list-branches-match-alt (implies (imf-cst-matchp cst "mailbox-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( mailbox *( \",\" mailbox ) ) / obs-mbox-list")))
Theorem:
(defthm imf-cst-address-list-branches-match-alt (implies (imf-cst-matchp cst "address-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( address *( \",\" address ) ) / obs-addr-list")))
Theorem:
(defthm imf-cst-group-list-branches-match-alt (implies (imf-cst-matchp cst "group-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "mailbox-list / cfws / obs-group-list")))
Theorem:
(defthm imf-cst-addr-spec-branches-match-alt (implies (imf-cst-matchp cst "addr-spec") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "local-part \"@\" domain")))
Theorem:
(defthm imf-cst-local-part-branches-match-alt (implies (imf-cst-matchp cst "local-part") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom / quoted-string / obs-local-part")))
Theorem:
(defthm imf-cst-domain-branches-match-alt (implies (imf-cst-matchp cst "domain") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom / domain-literal / obs-domain")))
Theorem:
(defthm imf-cst-domain-literal-branches-match-alt (implies (imf-cst-matchp cst "domain-literal") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]")))
Theorem:
(defthm imf-cst-dtext-branches-match-alt (implies (imf-cst-matchp cst "dtext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-90 / %d94-126 / obs-dtext")))
Theorem:
(defthm imf-cst-message-branches-match-alt (implies (imf-cst-matchp cst "message") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( fields / obs-fields ) [ crlf body ]")))
Theorem:
(defthm imf-cst-body-branches-match-alt (implies (imf-cst-matchp cst "body") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( *( *998text crlf ) *998text ) / obs-body")))
Theorem:
(defthm imf-cst-text-branches-match-alt (implies (imf-cst-matchp cst "text") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d1-9 / %d11 / %d12 / %d14-127")))
Theorem:
(defthm imf-cst-fields-branches-match-alt (implies (imf-cst-matchp cst "fields") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( trace *optional-field / *( resent-date / resent-from / resent-sender / resent-to / resent-cc / resent-bcc / resent-msg-id ) ) *( orig-date / from / sender / reply-to / to / cc / bcc / message-id / in-reply-to / references / subject / comments / keywords / optional-field )")))
Theorem:
(defthm imf-cst-orig-date-branches-match-alt (implies (imf-cst-matchp cst "orig-date") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Date:\" date-time crlf")))
Theorem:
(defthm imf-cst-from-branches-match-alt (implies (imf-cst-matchp cst "from") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"From:\" mailbox-list crlf")))
Theorem:
(defthm imf-cst-sender-branches-match-alt (implies (imf-cst-matchp cst "sender") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Sender:\" mailbox crlf")))
Theorem:
(defthm imf-cst-reply-to-branches-match-alt (implies (imf-cst-matchp cst "reply-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Reply-To:\" address-list crlf")))
Theorem:
(defthm imf-cst-to-branches-match-alt (implies (imf-cst-matchp cst "to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"To:\" address-list crlf")))
Theorem:
(defthm imf-cst-cc-branches-match-alt (implies (imf-cst-matchp cst "cc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Cc:\" address-list crlf")))
Theorem:
(defthm imf-cst-bcc-branches-match-alt (implies (imf-cst-matchp cst "bcc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Bcc:\" [ address-list / cfws ] crlf")))
Theorem:
(defthm imf-cst-message-id-branches-match-alt (implies (imf-cst-matchp cst "message-id") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Message-ID:\" msg-id crlf")))
Theorem:
(defthm imf-cst-in-reply-to-branches-match-alt (implies (imf-cst-matchp cst "in-reply-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"In-Reply-To:\" 1*msg-id crlf")))
Theorem:
(defthm imf-cst-references-branches-match-alt (implies (imf-cst-matchp cst "references") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"References:\" 1*msg-id crlf")))
Theorem:
(defthm imf-cst-msg-id-branches-match-alt (implies (imf-cst-matchp cst "msg-id") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]")))
Theorem:
(defthm imf-cst-id-left-branches-match-alt (implies (imf-cst-matchp cst "id-left") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom-text / obs-id-left")))
Theorem:
(defthm imf-cst-id-right-branches-match-alt (implies (imf-cst-matchp cst "id-right") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dot-atom-text / no-fold-literal / obs-id-right")))
Theorem:
(defthm imf-cst-no-fold-literal-branches-match-alt (implies (imf-cst-matchp cst "no-fold-literal") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"[\" *dtext \"]\"")))
Theorem:
(defthm imf-cst-subject-branches-match-alt (implies (imf-cst-matchp cst "subject") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Subject:\" unstructured crlf")))
Theorem:
(defthm imf-cst-comments-branches-match-alt (implies (imf-cst-matchp cst "comments") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Comments:\" unstructured crlf")))
Theorem:
(defthm imf-cst-keywords-branches-match-alt (implies (imf-cst-matchp cst "keywords") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Keywords:\" phrase *( \",\" phrase ) crlf")))
Theorem:
(defthm imf-cst-resent-date-branches-match-alt (implies (imf-cst-matchp cst "resent-date") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Date:\" date-time crlf")))
Theorem:
(defthm imf-cst-resent-from-branches-match-alt (implies (imf-cst-matchp cst "resent-from") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-From:\" mailbox-list crlf")))
Theorem:
(defthm imf-cst-resent-sender-branches-match-alt (implies (imf-cst-matchp cst "resent-sender") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Sender:\" mailbox crlf")))
Theorem:
(defthm imf-cst-resent-to-branches-match-alt (implies (imf-cst-matchp cst "resent-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-To:\" address-list crlf")))
Theorem:
(defthm imf-cst-resent-cc-branches-match-alt (implies (imf-cst-matchp cst "resent-cc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Cc:\" address-list crlf")))
Theorem:
(defthm imf-cst-resent-bcc-branches-match-alt (implies (imf-cst-matchp cst "resent-bcc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Bcc:\" [ address-list / cfws ] crlf")))
Theorem:
(defthm imf-cst-resent-msg-id-branches-match-alt (implies (imf-cst-matchp cst "resent-msg-id") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Message-ID:\" msg-id crlf")))
Theorem:
(defthm imf-cst-trace-branches-match-alt (implies (imf-cst-matchp cst "trace") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ return ] 1*received")))
Theorem:
(defthm imf-cst-return-branches-match-alt (implies (imf-cst-matchp cst "return") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Return-Path:\" path crlf")))
Theorem:
(defthm imf-cst-path-branches-match-alt (implies (imf-cst-matchp cst "path") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "angle-addr / ( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )")))
Theorem:
(defthm imf-cst-received-branches-match-alt (implies (imf-cst-matchp cst "received") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Received:\" *received-token \";\" date-time crlf")))
Theorem:
(defthm imf-cst-received-token-branches-match-alt (implies (imf-cst-matchp cst "received-token") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "word / angle-addr / addr-spec / domain")))
Theorem:
(defthm imf-cst-optional-field-branches-match-alt (implies (imf-cst-matchp cst "optional-field") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "field-name \":\" unstructured crlf")))
Theorem:
(defthm imf-cst-field-name-branches-match-alt (implies (imf-cst-matchp cst "field-name") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*ftext")))
Theorem:
(defthm imf-cst-ftext-branches-match-alt (implies (imf-cst-matchp cst "ftext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d33-57 / %d59-126")))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-branches-match-alt (implies (imf-cst-matchp cst "obs-no-ws-ctl") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d1-8 / %d11 / %d12 / %d14-31 / %d127")))
Theorem:
(defthm imf-cst-obs-ctext-branches-match-alt (implies (imf-cst-matchp cst "obs-ctext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl")))
Theorem:
(defthm imf-cst-obs-qtext-branches-match-alt (implies (imf-cst-matchp cst "obs-qtext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl")))
Theorem:
(defthm imf-cst-obs-utext-branches-match-alt (implies (imf-cst-matchp cst "obs-utext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%d0 / obs-no-ws-ctl / vchar")))
Theorem:
(defthm imf-cst-obs-qp-branches-match-alt (implies (imf-cst-matchp cst "obs-qp") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )")))
Theorem:
(defthm imf-cst-obs-body-branches-match-alt (implies (imf-cst-matchp cst "obs-body") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )")))
Theorem:
(defthm imf-cst-obs-unstruct-branches-match-alt (implies (imf-cst-matchp cst "obs-unstruct") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )")))
Theorem:
(defthm imf-cst-obs-phrase-branches-match-alt (implies (imf-cst-matchp cst "obs-phrase") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "word *( word / \".\" / cfws )")))
Theorem:
(defthm imf-cst-obs-phrase-list-branches-match-alt (implies (imf-cst-matchp cst "obs-phrase-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ phrase / cfws ] *( \",\" [ phrase / cfws ] )")))
Theorem:
(defthm imf-cst-obs-fws-branches-match-alt (implies (imf-cst-matchp cst "obs-fws") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*wsp *( crlf 1*wsp )")))
Theorem:
(defthm imf-cst-obs-day-of-week-branches-match-alt (implies (imf-cst-matchp cst "obs-day-of-week") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] day-name [ cfws ]")))
Theorem:
(defthm imf-cst-obs-day-branches-match-alt (implies (imf-cst-matchp cst "obs-day") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 1*2digit [ cfws ]")))
Theorem:
(defthm imf-cst-obs-year-branches-match-alt (implies (imf-cst-matchp cst "obs-year") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2*digit [ cfws ]")))
Theorem:
(defthm imf-cst-obs-hour-branches-match-alt (implies (imf-cst-matchp cst "obs-hour") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm imf-cst-obs-minute-branches-match-alt (implies (imf-cst-matchp cst "obs-minute") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm imf-cst-obs-second-branches-match-alt (implies (imf-cst-matchp cst "obs-second") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] 2digit [ cfws ]")))
Theorem:
(defthm imf-cst-obs-zone-branches-match-alt (implies (imf-cst-matchp cst "obs-zone") (imf-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 imf-cst-obs-angle-addr-branches-match-alt (implies (imf-cst-matchp cst "obs-angle-addr") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ cfws ] \"<\" obs-route addr-spec \">\" [ cfws ]")))
Theorem:
(defthm imf-cst-obs-route-branches-match-alt (implies (imf-cst-matchp cst "obs-route") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-domain-list \":\"")))
Theorem:
(defthm imf-cst-obs-domain-list-branches-match-alt (implies (imf-cst-matchp cst "obs-domain-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( cfws / \",\" ) \"@\" domain *( \",\" [ cfws ] [ \"@\" domain ] )")))
Theorem:
(defthm imf-cst-obs-mbox-list-branches-match-alt (implies (imf-cst-matchp cst "obs-mbox-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( [ cfws ] \",\" ) mailbox *( \",\" [ mailbox / cfws ] )")))
Theorem:
(defthm imf-cst-obs-addr-list-branches-match-alt (implies (imf-cst-matchp cst "obs-addr-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( [ cfws ] \",\" ) address *( \",\" [ address / cfws ] )")))
Theorem:
(defthm imf-cst-obs-group-list-branches-match-alt (implies (imf-cst-matchp cst "obs-group-list") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( [ cfws ] \",\" ) [ cfws ]")))
Theorem:
(defthm imf-cst-obs-local-part-branches-match-alt (implies (imf-cst-matchp cst "obs-local-part") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "word *( \".\" word )")))
Theorem:
(defthm imf-cst-obs-domain-branches-match-alt (implies (imf-cst-matchp cst "obs-domain") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom *( \".\" atom )")))
Theorem:
(defthm imf-cst-obs-dtext-branches-match-alt (implies (imf-cst-matchp cst "obs-dtext") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl / quoted-pair")))
Theorem:
(defthm imf-cst-obs-fields-branches-match-alt (implies (imf-cst-matchp cst "obs-fields") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )")))
Theorem:
(defthm imf-cst-obs-orig-date-branches-match-alt (implies (imf-cst-matchp cst "obs-orig-date") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Date\" *wsp \":\" date-time crlf")))
Theorem:
(defthm imf-cst-obs-from-branches-match-alt (implies (imf-cst-matchp cst "obs-from") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"From\" *wsp \":\" mailbox-list crlf")))
Theorem:
(defthm imf-cst-obs-sender-branches-match-alt (implies (imf-cst-matchp cst "obs-sender") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Sender\" *wsp \":\" mailbox crlf")))
Theorem:
(defthm imf-cst-obs-reply-to-branches-match-alt (implies (imf-cst-matchp cst "obs-reply-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Reply-To\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-to-branches-match-alt (implies (imf-cst-matchp cst "obs-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"To\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-cc-branches-match-alt (implies (imf-cst-matchp cst "obs-cc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Cc\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-bcc-branches-match-alt (implies (imf-cst-matchp cst "obs-bcc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf")))
Theorem:
(defthm imf-cst-obs-message-id-branches-match-alt (implies (imf-cst-matchp cst "obs-message-id") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Message-ID\" *wsp \":\" msg-id crlf")))
Theorem:
(defthm imf-cst-obs-in-reply-to-branches-match-alt (implies (imf-cst-matchp cst "obs-in-reply-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"In-Reply-To\" *wsp \":\" *( phrase / msg-id ) crlf")))
Theorem:
(defthm imf-cst-obs-references-branches-match-alt (implies (imf-cst-matchp cst "obs-references") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"References\" *wsp \":\" *( phrase / msg-id ) crlf")))
Theorem:
(defthm imf-cst-obs-id-left-branches-match-alt (implies (imf-cst-matchp cst "obs-id-left") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "local-part")))
Theorem:
(defthm imf-cst-obs-id-right-branches-match-alt (implies (imf-cst-matchp cst "obs-id-right") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "domain")))
Theorem:
(defthm imf-cst-obs-subject-branches-match-alt (implies (imf-cst-matchp cst "obs-subject") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Subject\" *wsp \":\" unstructured crlf")))
Theorem:
(defthm imf-cst-obs-comments-branches-match-alt (implies (imf-cst-matchp cst "obs-comments") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Comments\" *wsp \":\" unstructured crlf")))
Theorem:
(defthm imf-cst-obs-keywords-branches-match-alt (implies (imf-cst-matchp cst "obs-keywords") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Keywords\" *wsp \":\" obs-phrase-list crlf")))
Theorem:
(defthm imf-cst-obs-resent-from-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-from") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-From\" *wsp \":\" mailbox-list crlf")))
Theorem:
(defthm imf-cst-obs-resent-send-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-send") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Sender\" *wsp \":\" mailbox crlf")))
Theorem:
(defthm imf-cst-obs-resent-date-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-date") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Date\" *wsp \":\" date-time crlf")))
Theorem:
(defthm imf-cst-obs-resent-to-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-to") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-To\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-resent-cc-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-cc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Cc\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-resent-bcc-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-bcc") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf")))
Theorem:
(defthm imf-cst-obs-resent-mid-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-mid") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Message-ID\" *wsp \":\" msg-id crlf")))
Theorem:
(defthm imf-cst-obs-resent-rply-branches-match-alt (implies (imf-cst-matchp cst "obs-resent-rply") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Resent-Reply-To\" *wsp \":\" address-list crlf")))
Theorem:
(defthm imf-cst-obs-return-branches-match-alt (implies (imf-cst-matchp cst "obs-return") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Return-Path\" *wsp \":\" path crlf")))
Theorem:
(defthm imf-cst-obs-received-branches-match-alt (implies (imf-cst-matchp cst "obs-received") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Received\" *wsp \":\" *received-token crlf")))
Theorem:
(defthm imf-cst-obs-optional-branches-match-alt (implies (imf-cst-matchp cst "obs-optional") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "field-name *wsp \":\" unstructured crlf")))
Theorem:
(defthm imf-cst-alpha-branches-match-alt (implies (imf-cst-matchp cst "alpha") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x41-5A / %x61-7A")))
Theorem:
(defthm imf-cst-cr-branches-match-alt (implies (imf-cst-matchp cst "cr") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xD")))
Theorem:
(defthm imf-cst-crlf-branches-match-alt (implies (imf-cst-matchp cst "crlf") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cr lf")))
Theorem:
(defthm imf-cst-digit-branches-match-alt (implies (imf-cst-matchp cst "digit") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30-39")))
Theorem:
(defthm imf-cst-dquote-branches-match-alt (implies (imf-cst-matchp cst "dquote") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x22")))
Theorem:
(defthm imf-cst-lf-branches-match-alt (implies (imf-cst-matchp cst "lf") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xA")))
Theorem:
(defthm imf-cst-vchar-branches-match-alt (implies (imf-cst-matchp cst "vchar") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x21-7E")))
Theorem:
(defthm imf-cst-wsp-branches-match-alt (implies (imf-cst-matchp cst "wsp") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "sp / htab")))
Theorem:
(defthm imf-cst-htab-branches-match-alt (implies (imf-cst-matchp cst "htab") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x9")))
Theorem:
(defthm imf-cst-sp-branches-match-alt (implies (imf-cst-matchp cst "sp") (imf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20")))
Theorem:
(defthm imf-cst-quoted-pair-concs (implies (imf-cst-list-list-alt-matchp cstss "( \"\\\" ( vchar / wsp ) ) / obs-qp") (or (imf-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )") (imf-cst-list-list-conc-matchp cstss "obs-qp"))))
Theorem:
(defthm imf-cst-fws-concs (implies (imf-cst-list-list-alt-matchp cstss "( [ *wsp crlf ] 1*wsp ) / obs-fws") (or (imf-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )") (imf-cst-list-list-conc-matchp cstss "obs-fws"))))
Theorem:
(defthm imf-cst-ctext-concs (implies (imf-cst-list-list-alt-matchp cstss "%d33-39 / %d42-91 / %d93-126 / obs-ctext") (or (imf-cst-list-list-conc-matchp cstss "%d33-39") (imf-cst-list-list-conc-matchp cstss "%d42-91") (imf-cst-list-list-conc-matchp cstss "%d93-126") (imf-cst-list-list-conc-matchp cstss "obs-ctext"))))
Theorem:
(defthm imf-cst-ccontent-concs (implies (imf-cst-list-list-alt-matchp cstss "ctext / quoted-pair / comment") (or (imf-cst-list-list-conc-matchp cstss "ctext") (imf-cst-list-list-conc-matchp cstss "quoted-pair") (imf-cst-list-list-conc-matchp cstss "comment"))))
Theorem:
(defthm imf-cst-comment-concs (implies (imf-cst-list-list-alt-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"") (or (imf-cst-list-list-conc-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\""))))
Theorem:
(defthm imf-cst-cfws-concs (implies (imf-cst-list-list-alt-matchp cstss "( 1*( [ fws ] comment ) [ fws ] ) / fws") (or (imf-cst-list-list-conc-matchp cstss "( 1*( [ fws ] comment ) [ fws ] )") (imf-cst-list-list-conc-matchp cstss "fws"))))
Theorem:
(defthm imf-cst-atext-concs (implies (imf-cst-list-list-alt-matchp cstss "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"") (or (imf-cst-list-list-conc-matchp cstss "alpha") (imf-cst-list-list-conc-matchp cstss "digit") (imf-cst-list-list-conc-matchp cstss "\"!\"") (imf-cst-list-list-conc-matchp cstss "\"#\"") (imf-cst-list-list-conc-matchp cstss "\"$\"") (imf-cst-list-list-conc-matchp cstss "\"%\"") (imf-cst-list-list-conc-matchp cstss "\"&\"") (imf-cst-list-list-conc-matchp cstss "\"'\"") (imf-cst-list-list-conc-matchp cstss "\"*\"") (imf-cst-list-list-conc-matchp cstss "\"+\"") (imf-cst-list-list-conc-matchp cstss "\"-\"") (imf-cst-list-list-conc-matchp cstss "\"/\"") (imf-cst-list-list-conc-matchp cstss "\"=\"") (imf-cst-list-list-conc-matchp cstss "\"?\"") (imf-cst-list-list-conc-matchp cstss "\"^\"") (imf-cst-list-list-conc-matchp cstss "\"_\"") (imf-cst-list-list-conc-matchp cstss "\"`\"") (imf-cst-list-list-conc-matchp cstss "\"{\"") (imf-cst-list-list-conc-matchp cstss "\"|\"") (imf-cst-list-list-conc-matchp cstss "\"}\"") (imf-cst-list-list-conc-matchp cstss "\"~\""))))
Theorem:
(defthm imf-cst-atom-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 1*atext [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 1*atext [ cfws ]"))))
Theorem:
(defthm imf-cst-dot-atom-text-concs (implies (imf-cst-list-list-alt-matchp cstss "1*atext *( \".\" 1*atext )") (or (imf-cst-list-list-conc-matchp cstss "1*atext *( \".\" 1*atext )"))))
Theorem:
(defthm imf-cst-dot-atom-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] dot-atom-text [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] dot-atom-text [ cfws ]"))))
Theorem:
(defthm imf-cst-specials-concs (implies (imf-cst-list-list-alt-matchp cstss "\"(\" / \")\" / \"<\" / \">\" / \"[\" / \"]\" / \":\" / \";\" / \"@\" / \"\\\" / \",\" / \".\" / dquote") (or (imf-cst-list-list-conc-matchp cstss "\"(\"") (imf-cst-list-list-conc-matchp cstss "\")\"") (imf-cst-list-list-conc-matchp cstss "\"<\"") (imf-cst-list-list-conc-matchp cstss "\">\"") (imf-cst-list-list-conc-matchp cstss "\"[\"") (imf-cst-list-list-conc-matchp cstss "\"]\"") (imf-cst-list-list-conc-matchp cstss "\":\"") (imf-cst-list-list-conc-matchp cstss "\";\"") (imf-cst-list-list-conc-matchp cstss "\"@\"") (imf-cst-list-list-conc-matchp cstss "\"\\\"") (imf-cst-list-list-conc-matchp cstss "\",\"") (imf-cst-list-list-conc-matchp cstss "\".\"") (imf-cst-list-list-conc-matchp cstss "dquote"))))
Theorem:
(defthm imf-cst-qtext-concs (implies (imf-cst-list-list-alt-matchp cstss "%d33 / %d35-91 / %d93-126 / obs-qtext") (or (imf-cst-list-list-conc-matchp cstss "%d33") (imf-cst-list-list-conc-matchp cstss "%d35-91") (imf-cst-list-list-conc-matchp cstss "%d93-126") (imf-cst-list-list-conc-matchp cstss "obs-qtext"))))
Theorem:
(defthm imf-cst-qcontent-concs (implies (imf-cst-list-list-alt-matchp cstss "qtext / quoted-pair") (or (imf-cst-list-list-conc-matchp cstss "qtext") (imf-cst-list-list-conc-matchp cstss "quoted-pair"))))
Theorem:
(defthm imf-cst-quoted-string-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]"))))
Theorem:
(defthm imf-cst-word-concs (implies (imf-cst-list-list-alt-matchp cstss "atom / quoted-string") (or (imf-cst-list-list-conc-matchp cstss "atom") (imf-cst-list-list-conc-matchp cstss "quoted-string"))))
Theorem:
(defthm imf-cst-phrase-concs (implies (imf-cst-list-list-alt-matchp cstss "1*word / obs-phrase") (or (imf-cst-list-list-conc-matchp cstss "1*word") (imf-cst-list-list-conc-matchp cstss "obs-phrase"))))
Theorem:
(defthm imf-cst-unstructured-concs (implies (imf-cst-list-list-alt-matchp cstss "( *( [ fws ] vchar ) *wsp ) / obs-unstruct") (or (imf-cst-list-list-conc-matchp cstss "( *( [ fws ] vchar ) *wsp )") (imf-cst-list-list-conc-matchp cstss "obs-unstruct"))))
Theorem:
(defthm imf-cst-date-time-concs (implies (imf-cst-list-list-alt-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]"))))
Theorem:
(defthm imf-cst-day-of-week-concs (implies (imf-cst-list-list-alt-matchp cstss "( [ fws ] day-name ) / obs-day-of-week") (or (imf-cst-list-list-conc-matchp cstss "( [ fws ] day-name )") (imf-cst-list-list-conc-matchp cstss "obs-day-of-week"))))
Theorem:
(defthm imf-cst-day-name-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"") (or (imf-cst-list-list-conc-matchp cstss "\"Mon\"") (imf-cst-list-list-conc-matchp cstss "\"Tue\"") (imf-cst-list-list-conc-matchp cstss "\"Wed\"") (imf-cst-list-list-conc-matchp cstss "\"Thu\"") (imf-cst-list-list-conc-matchp cstss "\"Fri\"") (imf-cst-list-list-conc-matchp cstss "\"Sat\"") (imf-cst-list-list-conc-matchp cstss "\"Sun\""))))
Theorem:
(defthm imf-cst-date-concs (implies (imf-cst-list-list-alt-matchp cstss "day month year") (or (imf-cst-list-list-conc-matchp cstss "day month year"))))
Theorem:
(defthm imf-cst-day-concs (implies (imf-cst-list-list-alt-matchp cstss "( [ fws ] 1*2digit fws ) / obs-day") (or (imf-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )") (imf-cst-list-list-conc-matchp cstss "obs-day"))))
Theorem:
(defthm imf-cst-month-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"") (or (imf-cst-list-list-conc-matchp cstss "\"Jan\"") (imf-cst-list-list-conc-matchp cstss "\"Feb\"") (imf-cst-list-list-conc-matchp cstss "\"Mar\"") (imf-cst-list-list-conc-matchp cstss "\"Apr\"") (imf-cst-list-list-conc-matchp cstss "\"May\"") (imf-cst-list-list-conc-matchp cstss "\"Jun\"") (imf-cst-list-list-conc-matchp cstss "\"Jul\"") (imf-cst-list-list-conc-matchp cstss "\"Aug\"") (imf-cst-list-list-conc-matchp cstss "\"Sep\"") (imf-cst-list-list-conc-matchp cstss "\"Oct\"") (imf-cst-list-list-conc-matchp cstss "\"Nov\"") (imf-cst-list-list-conc-matchp cstss "\"Dec\""))))
Theorem:
(defthm imf-cst-year-concs (implies (imf-cst-list-list-alt-matchp cstss "( fws 4*digit fws ) / obs-year") (or (imf-cst-list-list-conc-matchp cstss "( fws 4*digit fws )") (imf-cst-list-list-conc-matchp cstss "obs-year"))))
Theorem:
(defthm imf-cst-time-concs (implies (imf-cst-list-list-alt-matchp cstss "time-of-day zone") (or (imf-cst-list-list-conc-matchp cstss "time-of-day zone"))))
Theorem:
(defthm imf-cst-time-of-day-concs (implies (imf-cst-list-list-alt-matchp cstss "hour \":\" minute [ \":\" second ]") (or (imf-cst-list-list-conc-matchp cstss "hour \":\" minute [ \":\" second ]"))))
Theorem:
(defthm imf-cst-hour-concs (implies (imf-cst-list-list-alt-matchp cstss "2digit / obs-hour") (or (imf-cst-list-list-conc-matchp cstss "2digit") (imf-cst-list-list-conc-matchp cstss "obs-hour"))))
Theorem:
(defthm imf-cst-minute-concs (implies (imf-cst-list-list-alt-matchp cstss "2digit / obs-minute") (or (imf-cst-list-list-conc-matchp cstss "2digit") (imf-cst-list-list-conc-matchp cstss "obs-minute"))))
Theorem:
(defthm imf-cst-second-concs (implies (imf-cst-list-list-alt-matchp cstss "2digit / obs-second") (or (imf-cst-list-list-conc-matchp cstss "2digit") (imf-cst-list-list-conc-matchp cstss "obs-second"))))
Theorem:
(defthm imf-cst-zone-concs (implies (imf-cst-list-list-alt-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone") (or (imf-cst-list-list-conc-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit )") (imf-cst-list-list-conc-matchp cstss "obs-zone"))))
Theorem:
(defthm imf-cst-address-concs (implies (imf-cst-list-list-alt-matchp cstss "mailbox / group") (or (imf-cst-list-list-conc-matchp cstss "mailbox") (imf-cst-list-list-conc-matchp cstss "group"))))
Theorem:
(defthm imf-cst-mailbox-concs (implies (imf-cst-list-list-alt-matchp cstss "name-addr / addr-spec") (or (imf-cst-list-list-conc-matchp cstss "name-addr") (imf-cst-list-list-conc-matchp cstss "addr-spec"))))
Theorem:
(defthm imf-cst-name-addr-concs (implies (imf-cst-list-list-alt-matchp cstss "[ display-name ] angle-addr") (or (imf-cst-list-list-conc-matchp cstss "[ display-name ] angle-addr"))))
Theorem:
(defthm imf-cst-angle-addr-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] \"<\" addr-spec \">\" [ cfws ] / obs-angle-addr") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" addr-spec \">\" [ cfws ]") (imf-cst-list-list-conc-matchp cstss "obs-angle-addr"))))
Theorem:
(defthm imf-cst-group-concs (implies (imf-cst-list-list-alt-matchp cstss "display-name \":\" [ group-list ] \";\" [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "display-name \":\" [ group-list ] \";\" [ cfws ]"))))
Theorem:
(defthm imf-cst-display-name-concs (implies (imf-cst-list-list-alt-matchp cstss "phrase") (or (imf-cst-list-list-conc-matchp cstss "phrase"))))
Theorem:
(defthm imf-cst-mailbox-list-concs (implies (imf-cst-list-list-alt-matchp cstss "( mailbox *( \",\" mailbox ) ) / obs-mbox-list") (or (imf-cst-list-list-conc-matchp cstss "( mailbox *( \",\" mailbox ) )") (imf-cst-list-list-conc-matchp cstss "obs-mbox-list"))))
Theorem:
(defthm imf-cst-address-list-concs (implies (imf-cst-list-list-alt-matchp cstss "( address *( \",\" address ) ) / obs-addr-list") (or (imf-cst-list-list-conc-matchp cstss "( address *( \",\" address ) )") (imf-cst-list-list-conc-matchp cstss "obs-addr-list"))))
Theorem:
(defthm imf-cst-group-list-concs (implies (imf-cst-list-list-alt-matchp cstss "mailbox-list / cfws / obs-group-list") (or (imf-cst-list-list-conc-matchp cstss "mailbox-list") (imf-cst-list-list-conc-matchp cstss "cfws") (imf-cst-list-list-conc-matchp cstss "obs-group-list"))))
Theorem:
(defthm imf-cst-addr-spec-concs (implies (imf-cst-list-list-alt-matchp cstss "local-part \"@\" domain") (or (imf-cst-list-list-conc-matchp cstss "local-part \"@\" domain"))))
Theorem:
(defthm imf-cst-local-part-concs (implies (imf-cst-list-list-alt-matchp cstss "dot-atom / quoted-string / obs-local-part") (or (imf-cst-list-list-conc-matchp cstss "dot-atom") (imf-cst-list-list-conc-matchp cstss "quoted-string") (imf-cst-list-list-conc-matchp cstss "obs-local-part"))))
Theorem:
(defthm imf-cst-domain-concs (implies (imf-cst-list-list-alt-matchp cstss "dot-atom / domain-literal / obs-domain") (or (imf-cst-list-list-conc-matchp cstss "dot-atom") (imf-cst-list-list-conc-matchp cstss "domain-literal") (imf-cst-list-list-conc-matchp cstss "obs-domain"))))
Theorem:
(defthm imf-cst-domain-literal-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]"))))
Theorem:
(defthm imf-cst-dtext-concs (implies (imf-cst-list-list-alt-matchp cstss "%d33-90 / %d94-126 / obs-dtext") (or (imf-cst-list-list-conc-matchp cstss "%d33-90") (imf-cst-list-list-conc-matchp cstss "%d94-126") (imf-cst-list-list-conc-matchp cstss "obs-dtext"))))
Theorem:
(defthm imf-cst-message-concs (implies (imf-cst-list-list-alt-matchp cstss "( fields / obs-fields ) [ crlf body ]") (or (imf-cst-list-list-conc-matchp cstss "( fields / obs-fields ) [ crlf body ]"))))
Theorem:
(defthm imf-cst-body-concs (implies (imf-cst-list-list-alt-matchp cstss "( *( *998text crlf ) *998text ) / obs-body") (or (imf-cst-list-list-conc-matchp cstss "( *( *998text crlf ) *998text )") (imf-cst-list-list-conc-matchp cstss "obs-body"))))
Theorem:
(defthm imf-cst-text-concs (implies (imf-cst-list-list-alt-matchp cstss "%d1-9 / %d11 / %d12 / %d14-127") (or (imf-cst-list-list-conc-matchp cstss "%d1-9") (imf-cst-list-list-conc-matchp cstss "%d11") (imf-cst-list-list-conc-matchp cstss "%d12") (imf-cst-list-list-conc-matchp cstss "%d14-127"))))
Theorem:
(defthm imf-cst-fields-concs (implies (imf-cst-list-list-alt-matchp cstss "*( trace *optional-field / *( resent-date / resent-from / resent-sender / resent-to / resent-cc / resent-bcc / resent-msg-id ) ) *( orig-date / from / sender / reply-to / to / cc / bcc / message-id / in-reply-to / references / subject / comments / keywords / optional-field )") (or (imf-cst-list-list-conc-matchp cstss "*( trace *optional-field / *( resent-date / resent-from / resent-sender / resent-to / resent-cc / resent-bcc / resent-msg-id ) ) *( orig-date / from / sender / reply-to / to / cc / bcc / message-id / in-reply-to / references / subject / comments / keywords / optional-field )"))))
Theorem:
(defthm imf-cst-orig-date-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Date:\" date-time crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Date:\" date-time crlf"))))
Theorem:
(defthm imf-cst-from-concs (implies (imf-cst-list-list-alt-matchp cstss "\"From:\" mailbox-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"From:\" mailbox-list crlf"))))
Theorem:
(defthm imf-cst-sender-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Sender:\" mailbox crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Sender:\" mailbox crlf"))))
Theorem:
(defthm imf-cst-reply-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Reply-To:\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Reply-To:\" address-list crlf"))))
Theorem:
(defthm imf-cst-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"To:\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"To:\" address-list crlf"))))
Theorem:
(defthm imf-cst-cc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Cc:\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Cc:\" address-list crlf"))))
Theorem:
(defthm imf-cst-bcc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Bcc:\" [ address-list / cfws ] crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Bcc:\" [ address-list / cfws ] crlf"))))
Theorem:
(defthm imf-cst-message-id-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Message-ID:\" msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Message-ID:\" msg-id crlf"))))
Theorem:
(defthm imf-cst-in-reply-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"In-Reply-To:\" 1*msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"In-Reply-To:\" 1*msg-id crlf"))))
Theorem:
(defthm imf-cst-references-concs (implies (imf-cst-list-list-alt-matchp cstss "\"References:\" 1*msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"References:\" 1*msg-id crlf"))))
Theorem:
(defthm imf-cst-msg-id-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]"))))
Theorem:
(defthm imf-cst-id-left-concs (implies (imf-cst-list-list-alt-matchp cstss "dot-atom-text / obs-id-left") (or (imf-cst-list-list-conc-matchp cstss "dot-atom-text") (imf-cst-list-list-conc-matchp cstss "obs-id-left"))))
Theorem:
(defthm imf-cst-id-right-concs (implies (imf-cst-list-list-alt-matchp cstss "dot-atom-text / no-fold-literal / obs-id-right") (or (imf-cst-list-list-conc-matchp cstss "dot-atom-text") (imf-cst-list-list-conc-matchp cstss "no-fold-literal") (imf-cst-list-list-conc-matchp cstss "obs-id-right"))))
Theorem:
(defthm imf-cst-no-fold-literal-concs (implies (imf-cst-list-list-alt-matchp cstss "\"[\" *dtext \"]\"") (or (imf-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\""))))
Theorem:
(defthm imf-cst-subject-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Subject:\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Subject:\" unstructured crlf"))))
Theorem:
(defthm imf-cst-comments-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Comments:\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Comments:\" unstructured crlf"))))
Theorem:
(defthm imf-cst-keywords-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Keywords:\" phrase *( \",\" phrase ) crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Keywords:\" phrase *( \",\" phrase ) crlf"))))
Theorem:
(defthm imf-cst-resent-date-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Date:\" date-time crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Date:\" date-time crlf"))))
Theorem:
(defthm imf-cst-resent-from-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-From:\" mailbox-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-From:\" mailbox-list crlf"))))
Theorem:
(defthm imf-cst-resent-sender-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Sender:\" mailbox crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Sender:\" mailbox crlf"))))
Theorem:
(defthm imf-cst-resent-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-To:\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-To:\" address-list crlf"))))
Theorem:
(defthm imf-cst-resent-cc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Cc:\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Cc:\" address-list crlf"))))
Theorem:
(defthm imf-cst-resent-bcc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Bcc:\" [ address-list / cfws ] crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Bcc:\" [ address-list / cfws ] crlf"))))
Theorem:
(defthm imf-cst-resent-msg-id-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Message-ID:\" msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Message-ID:\" msg-id crlf"))))
Theorem:
(defthm imf-cst-trace-concs (implies (imf-cst-list-list-alt-matchp cstss "[ return ] 1*received") (or (imf-cst-list-list-conc-matchp cstss "[ return ] 1*received"))))
Theorem:
(defthm imf-cst-return-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Return-Path:\" path crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Return-Path:\" path crlf"))))
Theorem:
(defthm imf-cst-path-concs (implies (imf-cst-list-list-alt-matchp cstss "angle-addr / ( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )") (or (imf-cst-list-list-conc-matchp cstss "angle-addr") (imf-cst-list-list-conc-matchp cstss "( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )"))))
Theorem:
(defthm imf-cst-received-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Received:\" *received-token \";\" date-time crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Received:\" *received-token \";\" date-time crlf"))))
Theorem:
(defthm imf-cst-received-token-concs (implies (imf-cst-list-list-alt-matchp cstss "word / angle-addr / addr-spec / domain") (or (imf-cst-list-list-conc-matchp cstss "word") (imf-cst-list-list-conc-matchp cstss "angle-addr") (imf-cst-list-list-conc-matchp cstss "addr-spec") (imf-cst-list-list-conc-matchp cstss "domain"))))
Theorem:
(defthm imf-cst-optional-field-concs (implies (imf-cst-list-list-alt-matchp cstss "field-name \":\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "field-name \":\" unstructured crlf"))))
Theorem:
(defthm imf-cst-field-name-concs (implies (imf-cst-list-list-alt-matchp cstss "1*ftext") (or (imf-cst-list-list-conc-matchp cstss "1*ftext"))))
Theorem:
(defthm imf-cst-ftext-concs (implies (imf-cst-list-list-alt-matchp cstss "%d33-57 / %d59-126") (or (imf-cst-list-list-conc-matchp cstss "%d33-57") (imf-cst-list-list-conc-matchp cstss "%d59-126"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-concs (implies (imf-cst-list-list-alt-matchp cstss "%d1-8 / %d11 / %d12 / %d14-31 / %d127") (or (imf-cst-list-list-conc-matchp cstss "%d1-8") (imf-cst-list-list-conc-matchp cstss "%d11") (imf-cst-list-list-conc-matchp cstss "%d12") (imf-cst-list-list-conc-matchp cstss "%d14-31") (imf-cst-list-list-conc-matchp cstss "%d127"))))
Theorem:
(defthm imf-cst-obs-ctext-concs (implies (imf-cst-list-list-alt-matchp cstss "obs-no-ws-ctl") (or (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-qtext-concs (implies (imf-cst-list-list-alt-matchp cstss "obs-no-ws-ctl") (or (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-utext-concs (implies (imf-cst-list-list-alt-matchp cstss "%d0 / obs-no-ws-ctl / vchar") (or (imf-cst-list-list-conc-matchp cstss "%d0") (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (imf-cst-list-list-conc-matchp cstss "vchar"))))
Theorem:
(defthm imf-cst-obs-qp-concs (implies (imf-cst-list-list-alt-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )") (or (imf-cst-list-list-conc-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )"))))
Theorem:
(defthm imf-cst-obs-body-concs (implies (imf-cst-list-list-alt-matchp cstss "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )") (or (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )"))))
Theorem:
(defthm imf-cst-obs-unstruct-concs (implies (imf-cst-list-list-alt-matchp cstss "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )") (or (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )"))))
Theorem:
(defthm imf-cst-obs-phrase-concs (implies (imf-cst-list-list-alt-matchp cstss "word *( word / \".\" / cfws )") (or (imf-cst-list-list-conc-matchp cstss "word *( word / \".\" / cfws )"))))
Theorem:
(defthm imf-cst-obs-phrase-list-concs (implies (imf-cst-list-list-alt-matchp cstss "[ phrase / cfws ] *( \",\" [ phrase / cfws ] )") (or (imf-cst-list-list-conc-matchp cstss "[ phrase / cfws ] *( \",\" [ phrase / cfws ] )"))))
Theorem:
(defthm imf-cst-obs-fws-concs (implies (imf-cst-list-list-alt-matchp cstss "1*wsp *( crlf 1*wsp )") (or (imf-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )"))))
Theorem:
(defthm imf-cst-obs-day-of-week-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] day-name [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] day-name [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-day-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 1*2digit [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 1*2digit [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-year-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 2*digit [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2*digit [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-hour-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-minute-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-second-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-zone-concs (implies (imf-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 (imf-cst-list-list-conc-matchp cstss "\"UT\"") (imf-cst-list-list-conc-matchp cstss "\"GMT\"") (imf-cst-list-list-conc-matchp cstss "\"EST\"") (imf-cst-list-list-conc-matchp cstss "\"EDT\"") (imf-cst-list-list-conc-matchp cstss "\"CST\"") (imf-cst-list-list-conc-matchp cstss "\"CDT\"") (imf-cst-list-list-conc-matchp cstss "\"MST\"") (imf-cst-list-list-conc-matchp cstss "\"MDT\"") (imf-cst-list-list-conc-matchp cstss "\"PST\"") (imf-cst-list-list-conc-matchp cstss "\"PDT\"") (imf-cst-list-list-conc-matchp cstss "%d65-73") (imf-cst-list-list-conc-matchp cstss "%d75-90") (imf-cst-list-list-conc-matchp cstss "%d97-105") (imf-cst-list-list-conc-matchp cstss "%d107-122"))))
Theorem:
(defthm imf-cst-obs-angle-addr-concs (implies (imf-cst-list-list-alt-matchp cstss "[ cfws ] \"<\" obs-route addr-spec \">\" [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" obs-route addr-spec \">\" [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-route-concs (implies (imf-cst-list-list-alt-matchp cstss "obs-domain-list \":\"") (or (imf-cst-list-list-conc-matchp cstss "obs-domain-list \":\""))))
Theorem:
(defthm imf-cst-obs-domain-list-concs (implies (imf-cst-list-list-alt-matchp cstss "*( cfws / \",\" ) \"@\" domain *( \",\" [ cfws ] [ \"@\" domain ] )") (or (imf-cst-list-list-conc-matchp cstss "*( cfws / \",\" ) \"@\" domain *( \",\" [ cfws ] [ \"@\" domain ] )"))))
Theorem:
(defthm imf-cst-obs-mbox-list-concs (implies (imf-cst-list-list-alt-matchp cstss "*( [ cfws ] \",\" ) mailbox *( \",\" [ mailbox / cfws ] )") (or (imf-cst-list-list-conc-matchp cstss "*( [ cfws ] \",\" ) mailbox *( \",\" [ mailbox / cfws ] )"))))
Theorem:
(defthm imf-cst-obs-addr-list-concs (implies (imf-cst-list-list-alt-matchp cstss "*( [ cfws ] \",\" ) address *( \",\" [ address / cfws ] )") (or (imf-cst-list-list-conc-matchp cstss "*( [ cfws ] \",\" ) address *( \",\" [ address / cfws ] )"))))
Theorem:
(defthm imf-cst-obs-group-list-concs (implies (imf-cst-list-list-alt-matchp cstss "1*( [ cfws ] \",\" ) [ cfws ]") (or (imf-cst-list-list-conc-matchp cstss "1*( [ cfws ] \",\" ) [ cfws ]"))))
Theorem:
(defthm imf-cst-obs-local-part-concs (implies (imf-cst-list-list-alt-matchp cstss "word *( \".\" word )") (or (imf-cst-list-list-conc-matchp cstss "word *( \".\" word )"))))
Theorem:
(defthm imf-cst-obs-domain-concs (implies (imf-cst-list-list-alt-matchp cstss "atom *( \".\" atom )") (or (imf-cst-list-list-conc-matchp cstss "atom *( \".\" atom )"))))
Theorem:
(defthm imf-cst-obs-dtext-concs (implies (imf-cst-list-list-alt-matchp cstss "obs-no-ws-ctl / quoted-pair") (or (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (imf-cst-list-list-conc-matchp cstss "quoted-pair"))))
Theorem:
(defthm imf-cst-obs-fields-concs (implies (imf-cst-list-list-alt-matchp cstss "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )") (or (imf-cst-list-list-conc-matchp cstss "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )"))))
Theorem:
(defthm imf-cst-obs-orig-date-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Date\" *wsp \":\" date-time crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Date\" *wsp \":\" date-time crlf"))))
Theorem:
(defthm imf-cst-obs-from-concs (implies (imf-cst-list-list-alt-matchp cstss "\"From\" *wsp \":\" mailbox-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"From\" *wsp \":\" mailbox-list crlf"))))
Theorem:
(defthm imf-cst-obs-sender-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Sender\" *wsp \":\" mailbox crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Sender\" *wsp \":\" mailbox crlf"))))
Theorem:
(defthm imf-cst-obs-reply-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Reply-To\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Reply-To\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"To\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"To\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-cc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Cc\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Cc\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-bcc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf"))))
Theorem:
(defthm imf-cst-obs-message-id-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Message-ID\" *wsp \":\" msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Message-ID\" *wsp \":\" msg-id crlf"))))
Theorem:
(defthm imf-cst-obs-in-reply-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"In-Reply-To\" *wsp \":\" *( phrase / msg-id ) crlf") (or (imf-cst-list-list-conc-matchp cstss "\"In-Reply-To\" *wsp \":\" *( phrase / msg-id ) crlf"))))
Theorem:
(defthm imf-cst-obs-references-concs (implies (imf-cst-list-list-alt-matchp cstss "\"References\" *wsp \":\" *( phrase / msg-id ) crlf") (or (imf-cst-list-list-conc-matchp cstss "\"References\" *wsp \":\" *( phrase / msg-id ) crlf"))))
Theorem:
(defthm imf-cst-obs-id-left-concs (implies (imf-cst-list-list-alt-matchp cstss "local-part") (or (imf-cst-list-list-conc-matchp cstss "local-part"))))
Theorem:
(defthm imf-cst-obs-id-right-concs (implies (imf-cst-list-list-alt-matchp cstss "domain") (or (imf-cst-list-list-conc-matchp cstss "domain"))))
Theorem:
(defthm imf-cst-obs-subject-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Subject\" *wsp \":\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Subject\" *wsp \":\" unstructured crlf"))))
Theorem:
(defthm imf-cst-obs-comments-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Comments\" *wsp \":\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Comments\" *wsp \":\" unstructured crlf"))))
Theorem:
(defthm imf-cst-obs-keywords-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Keywords\" *wsp \":\" obs-phrase-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Keywords\" *wsp \":\" obs-phrase-list crlf"))))
Theorem:
(defthm imf-cst-obs-resent-from-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-From\" *wsp \":\" mailbox-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-From\" *wsp \":\" mailbox-list crlf"))))
Theorem:
(defthm imf-cst-obs-resent-send-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Sender\" *wsp \":\" mailbox crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Sender\" *wsp \":\" mailbox crlf"))))
Theorem:
(defthm imf-cst-obs-resent-date-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Date\" *wsp \":\" date-time crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Date\" *wsp \":\" date-time crlf"))))
Theorem:
(defthm imf-cst-obs-resent-to-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-To\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-To\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-resent-cc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Cc\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Cc\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-resent-bcc-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf"))))
Theorem:
(defthm imf-cst-obs-resent-mid-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Message-ID\" *wsp \":\" msg-id crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Message-ID\" *wsp \":\" msg-id crlf"))))
Theorem:
(defthm imf-cst-obs-resent-rply-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Resent-Reply-To\" *wsp \":\" address-list crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Resent-Reply-To\" *wsp \":\" address-list crlf"))))
Theorem:
(defthm imf-cst-obs-return-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Return-Path\" *wsp \":\" path crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Return-Path\" *wsp \":\" path crlf"))))
Theorem:
(defthm imf-cst-obs-received-concs (implies (imf-cst-list-list-alt-matchp cstss "\"Received\" *wsp \":\" *received-token crlf") (or (imf-cst-list-list-conc-matchp cstss "\"Received\" *wsp \":\" *received-token crlf"))))
Theorem:
(defthm imf-cst-obs-optional-concs (implies (imf-cst-list-list-alt-matchp cstss "field-name *wsp \":\" unstructured crlf") (or (imf-cst-list-list-conc-matchp cstss "field-name *wsp \":\" unstructured crlf"))))
Theorem:
(defthm imf-cst-alpha-concs (implies (imf-cst-list-list-alt-matchp cstss "%x41-5A / %x61-7A") (or (imf-cst-list-list-conc-matchp cstss "%x41-5A") (imf-cst-list-list-conc-matchp cstss "%x61-7A"))))
Theorem:
(defthm imf-cst-cr-concs (implies (imf-cst-list-list-alt-matchp cstss "%xD") (or (imf-cst-list-list-conc-matchp cstss "%xD"))))
Theorem:
(defthm imf-cst-crlf-concs (implies (imf-cst-list-list-alt-matchp cstss "cr lf") (or (imf-cst-list-list-conc-matchp cstss "cr lf"))))
Theorem:
(defthm imf-cst-digit-concs (implies (imf-cst-list-list-alt-matchp cstss "%x30-39") (or (imf-cst-list-list-conc-matchp cstss "%x30-39"))))
Theorem:
(defthm imf-cst-dquote-concs (implies (imf-cst-list-list-alt-matchp cstss "%x22") (or (imf-cst-list-list-conc-matchp cstss "%x22"))))
Theorem:
(defthm imf-cst-lf-concs (implies (imf-cst-list-list-alt-matchp cstss "%xA") (or (imf-cst-list-list-conc-matchp cstss "%xA"))))
Theorem:
(defthm imf-cst-vchar-concs (implies (imf-cst-list-list-alt-matchp cstss "%x21-7E") (or (imf-cst-list-list-conc-matchp cstss "%x21-7E"))))
Theorem:
(defthm imf-cst-wsp-concs (implies (imf-cst-list-list-alt-matchp cstss "sp / htab") (or (imf-cst-list-list-conc-matchp cstss "sp") (imf-cst-list-list-conc-matchp cstss "htab"))))
Theorem:
(defthm imf-cst-htab-concs (implies (imf-cst-list-list-alt-matchp cstss "%x9") (or (imf-cst-list-list-conc-matchp cstss "%x9"))))
Theorem:
(defthm imf-cst-sp-concs (implies (imf-cst-list-list-alt-matchp cstss "%x20") (or (imf-cst-list-list-conc-matchp cstss "%x20"))))
Theorem:
(defthm imf-cst-quoted-pair-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( \"\\\" ( vchar / wsp ) )"))))
Theorem:
(defthm imf-cst-quoted-pair-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-qp") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-qp"))))
Theorem:
(defthm imf-cst-fws-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( [ *wsp crlf ] 1*wsp )"))))
Theorem:
(defthm imf-cst-fws-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-fws") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-fws"))))
Theorem:
(defthm imf-cst-ctext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d33-39") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d33-39"))))
Theorem:
(defthm imf-cst-ctext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d42-91") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d42-91"))))
Theorem:
(defthm imf-cst-ctext-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "%d93-126") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d93-126"))))
Theorem:
(defthm imf-cst-ctext-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-ctext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-ctext"))))
Theorem:
(defthm imf-cst-ccontent-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "ctext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "ctext"))))
Theorem:
(defthm imf-cst-ccontent-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm imf-cst-ccontent-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "comment") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "comment"))))
Theorem:
(defthm imf-cst-cfws-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( 1*( [ fws ] comment ) [ fws ] )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( 1*( [ fws ] comment ) [ fws ] )"))))
Theorem:
(defthm imf-cst-cfws-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "fws") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "fws"))))
Theorem:
(defthm imf-cst-atext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm imf-cst-atext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm imf-cst-atext-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "\"!\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"!\""))))
Theorem:
(defthm imf-cst-atext-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "\"#\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"#\""))))
Theorem:
(defthm imf-cst-atext-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "\"$\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"$\""))))
Theorem:
(defthm imf-cst-atext-conc6-matching (implies (imf-cst-list-list-conc-matchp cstss "\"%\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"%\""))))
Theorem:
(defthm imf-cst-atext-conc7-matching (implies (imf-cst-list-list-conc-matchp cstss "\"&\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"&\""))))
Theorem:
(defthm imf-cst-atext-conc8-matching (implies (imf-cst-list-list-conc-matchp cstss "\"'\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"'\""))))
Theorem:
(defthm imf-cst-atext-conc9-matching (implies (imf-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm imf-cst-atext-conc10-matching (implies (imf-cst-list-list-conc-matchp cstss "\"+\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"+\""))))
Theorem:
(defthm imf-cst-atext-conc11-matching (implies (imf-cst-list-list-conc-matchp cstss "\"-\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"-\""))))
Theorem:
(defthm imf-cst-atext-conc12-matching (implies (imf-cst-list-list-conc-matchp cstss "\"/\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"/\""))))
Theorem:
(defthm imf-cst-atext-conc13-matching (implies (imf-cst-list-list-conc-matchp cstss "\"=\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"=\""))))
Theorem:
(defthm imf-cst-atext-conc14-matching (implies (imf-cst-list-list-conc-matchp cstss "\"?\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"?\""))))
Theorem:
(defthm imf-cst-atext-conc15-matching (implies (imf-cst-list-list-conc-matchp cstss "\"^\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"^\""))))
Theorem:
(defthm imf-cst-atext-conc16-matching (implies (imf-cst-list-list-conc-matchp cstss "\"_\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"_\""))))
Theorem:
(defthm imf-cst-atext-conc17-matching (implies (imf-cst-list-list-conc-matchp cstss "\"`\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"`\""))))
Theorem:
(defthm imf-cst-atext-conc18-matching (implies (imf-cst-list-list-conc-matchp cstss "\"{\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"{\""))))
Theorem:
(defthm imf-cst-atext-conc19-matching (implies (imf-cst-list-list-conc-matchp cstss "\"|\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"|\""))))
Theorem:
(defthm imf-cst-atext-conc20-matching (implies (imf-cst-list-list-conc-matchp cstss "\"}\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"}\""))))
Theorem:
(defthm imf-cst-atext-conc21-matching (implies (imf-cst-list-list-conc-matchp cstss "\"~\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"~\""))))
Theorem:
(defthm imf-cst-specials-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "\"(\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"(\""))))
Theorem:
(defthm imf-cst-specials-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "\")\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\")\""))))
Theorem:
(defthm imf-cst-specials-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "\"<\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"<\""))))
Theorem:
(defthm imf-cst-specials-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "\">\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\">\""))))
Theorem:
(defthm imf-cst-specials-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "\"[\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"[\""))))
Theorem:
(defthm imf-cst-specials-conc6-matching (implies (imf-cst-list-list-conc-matchp cstss "\"]\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"]\""))))
Theorem:
(defthm imf-cst-specials-conc7-matching (implies (imf-cst-list-list-conc-matchp cstss "\":\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\":\""))))
Theorem:
(defthm imf-cst-specials-conc8-matching (implies (imf-cst-list-list-conc-matchp cstss "\";\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\";\""))))
Theorem:
(defthm imf-cst-specials-conc9-matching (implies (imf-cst-list-list-conc-matchp cstss "\"@\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"@\""))))
Theorem:
(defthm imf-cst-specials-conc10-matching (implies (imf-cst-list-list-conc-matchp cstss "\"\\\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"\\\""))))
Theorem:
(defthm imf-cst-specials-conc11-matching (implies (imf-cst-list-list-conc-matchp cstss "\",\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\",\""))))
Theorem:
(defthm imf-cst-specials-conc12-matching (implies (imf-cst-list-list-conc-matchp cstss "\".\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\".\""))))
Theorem:
(defthm imf-cst-specials-conc13-matching (implies (imf-cst-list-list-conc-matchp cstss "dquote") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "dquote"))))
Theorem:
(defthm imf-cst-qtext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d33") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d33"))))
Theorem:
(defthm imf-cst-qtext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d35-91") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d35-91"))))
Theorem:
(defthm imf-cst-qtext-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "%d93-126") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d93-126"))))
Theorem:
(defthm imf-cst-qtext-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-qtext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-qtext"))))
Theorem:
(defthm imf-cst-qcontent-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "qtext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "qtext"))))
Theorem:
(defthm imf-cst-qcontent-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm imf-cst-word-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm imf-cst-word-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "quoted-string") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "quoted-string"))))
Theorem:
(defthm imf-cst-phrase-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "1*word") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "1*word"))))
Theorem:
(defthm imf-cst-phrase-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-phrase") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-phrase"))))
Theorem:
(defthm imf-cst-unstructured-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( *( [ fws ] vchar ) *wsp )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( *( [ fws ] vchar ) *wsp )"))))
Theorem:
(defthm imf-cst-unstructured-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-unstruct") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-unstruct"))))
Theorem:
(defthm imf-cst-day-of-week-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( [ fws ] day-name )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( [ fws ] day-name )"))))
Theorem:
(defthm imf-cst-day-of-week-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-day-of-week") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-day-of-week"))))
Theorem:
(defthm imf-cst-day-name-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Mon\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Mon\""))))
Theorem:
(defthm imf-cst-day-name-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Tue\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Tue\""))))
Theorem:
(defthm imf-cst-day-name-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Wed\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Wed\""))))
Theorem:
(defthm imf-cst-day-name-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Thu\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Thu\""))))
Theorem:
(defthm imf-cst-day-name-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Fri\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Fri\""))))
Theorem:
(defthm imf-cst-day-name-conc6-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Sat\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Sat\""))))
Theorem:
(defthm imf-cst-day-name-conc7-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Sun\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Sun\""))))
Theorem:
(defthm imf-cst-day-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( [ fws ] 1*2digit fws )"))))
Theorem:
(defthm imf-cst-day-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-day") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-day"))))
Theorem:
(defthm imf-cst-month-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Jan\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Jan\""))))
Theorem:
(defthm imf-cst-month-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Feb\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Feb\""))))
Theorem:
(defthm imf-cst-month-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Mar\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Mar\""))))
Theorem:
(defthm imf-cst-month-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Apr\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Apr\""))))
Theorem:
(defthm imf-cst-month-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "\"May\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"May\""))))
Theorem:
(defthm imf-cst-month-conc6-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Jun\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Jun\""))))
Theorem:
(defthm imf-cst-month-conc7-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Jul\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Jul\""))))
Theorem:
(defthm imf-cst-month-conc8-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Aug\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Aug\""))))
Theorem:
(defthm imf-cst-month-conc9-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Sep\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Sep\""))))
Theorem:
(defthm imf-cst-month-conc10-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Oct\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Oct\""))))
Theorem:
(defthm imf-cst-month-conc11-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Nov\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Nov\""))))
Theorem:
(defthm imf-cst-month-conc12-matching (implies (imf-cst-list-list-conc-matchp cstss "\"Dec\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"Dec\""))))
Theorem:
(defthm imf-cst-year-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( fws 4*digit fws )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( fws 4*digit fws )"))))
Theorem:
(defthm imf-cst-year-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-year") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-year"))))
Theorem:
(defthm imf-cst-hour-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm imf-cst-hour-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-hour") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-hour"))))
Theorem:
(defthm imf-cst-minute-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm imf-cst-minute-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-minute") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-minute"))))
Theorem:
(defthm imf-cst-second-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm imf-cst-second-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-second") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-second"))))
Theorem:
(defthm imf-cst-zone-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( fws ( \"+\" / \"-\" ) 4digit )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( fws ( \"+\" / \"-\" ) 4digit )"))))
Theorem:
(defthm imf-cst-zone-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-zone") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-zone"))))
Theorem:
(defthm imf-cst-address-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "mailbox") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "mailbox"))))
Theorem:
(defthm imf-cst-address-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "group") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "group"))))
Theorem:
(defthm imf-cst-mailbox-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "name-addr") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "name-addr"))))
Theorem:
(defthm imf-cst-mailbox-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "addr-spec") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "addr-spec"))))
Theorem:
(defthm imf-cst-angle-addr-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-angle-addr") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-angle-addr"))))
Theorem:
(defthm imf-cst-display-name-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "phrase") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "phrase"))))
Theorem:
(defthm imf-cst-mailbox-list-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( mailbox *( \",\" mailbox ) )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( mailbox *( \",\" mailbox ) )"))))
Theorem:
(defthm imf-cst-mailbox-list-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-mbox-list") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-mbox-list"))))
Theorem:
(defthm imf-cst-address-list-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( address *( \",\" address ) )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( address *( \",\" address ) )"))))
Theorem:
(defthm imf-cst-address-list-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-addr-list") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-addr-list"))))
Theorem:
(defthm imf-cst-group-list-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "mailbox-list") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "mailbox-list"))))
Theorem:
(defthm imf-cst-group-list-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "cfws") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "cfws"))))
Theorem:
(defthm imf-cst-group-list-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-group-list") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-group-list"))))
Theorem:
(defthm imf-cst-local-part-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "dot-atom") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "dot-atom"))))
Theorem:
(defthm imf-cst-local-part-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "quoted-string") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "quoted-string"))))
Theorem:
(defthm imf-cst-local-part-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-local-part") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-local-part"))))
Theorem:
(defthm imf-cst-domain-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "dot-atom") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "dot-atom"))))
Theorem:
(defthm imf-cst-domain-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "domain-literal") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "domain-literal"))))
Theorem:
(defthm imf-cst-domain-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-domain") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-domain"))))
Theorem:
(defthm imf-cst-dtext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d33-90") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d33-90"))))
Theorem:
(defthm imf-cst-dtext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d94-126") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d94-126"))))
Theorem:
(defthm imf-cst-dtext-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-dtext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-dtext"))))
Theorem:
(defthm imf-cst-body-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "( *( *998text crlf ) *998text )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( *( *998text crlf ) *998text )"))))
Theorem:
(defthm imf-cst-body-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-body") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-body"))))
Theorem:
(defthm imf-cst-text-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d1-9") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d1-9"))))
Theorem:
(defthm imf-cst-text-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d11") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d11"))))
Theorem:
(defthm imf-cst-text-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "%d12") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d12"))))
Theorem:
(defthm imf-cst-text-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "%d14-127") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d14-127"))))
Theorem:
(defthm imf-cst-id-left-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "dot-atom-text") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-left-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-id-left") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-id-left"))))
Theorem:
(defthm imf-cst-id-right-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "dot-atom-text") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-right-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "no-fold-literal") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "no-fold-literal"))))
Theorem:
(defthm imf-cst-id-right-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-id-right") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-id-right"))))
Theorem:
(defthm imf-cst-path-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "angle-addr") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "angle-addr"))))
Theorem:
(defthm imf-cst-path-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )"))))
Theorem:
(defthm imf-cst-received-token-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "word") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "word"))))
Theorem:
(defthm imf-cst-received-token-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "angle-addr") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "angle-addr"))))
Theorem:
(defthm imf-cst-received-token-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "addr-spec") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "addr-spec"))))
Theorem:
(defthm imf-cst-received-token-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "domain") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "domain"))))
Theorem:
(defthm imf-cst-field-name-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "1*ftext") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "1*ftext"))))
Theorem:
(defthm imf-cst-ftext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d33-57") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d33-57"))))
Theorem:
(defthm imf-cst-ftext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d59-126") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d59-126"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d1-8") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d1-8"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%d11") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d11"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "%d12") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d12"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "%d14-31") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d14-31"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "%d127") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d127"))))
Theorem:
(defthm imf-cst-obs-ctext-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-qtext-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-utext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%d0") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d0"))))
Theorem:
(defthm imf-cst-obs-utext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-utext-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "vchar") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "vchar"))))
Theorem:
(defthm imf-cst-obs-body-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )"))))
Theorem:
(defthm imf-cst-obs-unstruct-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )"))))
Theorem:
(defthm imf-cst-obs-zone-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "\"UT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"UT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "\"GMT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"GMT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc3-matching (implies (imf-cst-list-list-conc-matchp cstss "\"EST\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"EST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc4-matching (implies (imf-cst-list-list-conc-matchp cstss "\"EDT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"EDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc5-matching (implies (imf-cst-list-list-conc-matchp cstss "\"CST\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"CST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc6-matching (implies (imf-cst-list-list-conc-matchp cstss "\"CDT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"CDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc7-matching (implies (imf-cst-list-list-conc-matchp cstss "\"MST\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"MST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc8-matching (implies (imf-cst-list-list-conc-matchp cstss "\"MDT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"MDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc9-matching (implies (imf-cst-list-list-conc-matchp cstss "\"PST\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"PST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc10-matching (implies (imf-cst-list-list-conc-matchp cstss "\"PDT\"") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "\"PDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc11-matching (implies (imf-cst-list-list-conc-matchp cstss "%d65-73") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d65-73"))))
Theorem:
(defthm imf-cst-obs-zone-conc12-matching (implies (imf-cst-list-list-conc-matchp cstss "%d75-90") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d75-90"))))
Theorem:
(defthm imf-cst-obs-zone-conc13-matching (implies (imf-cst-list-list-conc-matchp cstss "%d97-105") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d97-105"))))
Theorem:
(defthm imf-cst-obs-zone-conc14-matching (implies (imf-cst-list-list-conc-matchp cstss "%d107-122") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%d107-122"))))
Theorem:
(defthm imf-cst-obs-dtext-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-dtext-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "quoted-pair") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "quoted-pair"))))
Theorem:
(defthm imf-cst-obs-fields-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )"))))
Theorem:
(defthm imf-cst-obs-id-left-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "local-part") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "local-part"))))
Theorem:
(defthm imf-cst-obs-id-right-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "domain") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "domain"))))
Theorem:
(defthm imf-cst-alpha-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "%x41-5A") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x41-5A"))))
Theorem:
(defthm imf-cst-alpha-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "%x61-7A") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x61-7A"))))
Theorem:
(defthm imf-cst-cr-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%xD") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%xD"))))
Theorem:
(defthm imf-cst-digit-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%x30-39") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x30-39"))))
Theorem:
(defthm imf-cst-dquote-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%x22") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x22"))))
Theorem:
(defthm imf-cst-lf-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%xA") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%xA"))))
Theorem:
(defthm imf-cst-vchar-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%x21-7E") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x21-7E"))))
Theorem:
(defthm imf-cst-wsp-conc1-matching (implies (imf-cst-list-list-conc-matchp cstss "sp") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "sp"))))
Theorem:
(defthm imf-cst-wsp-conc2-matching (implies (imf-cst-list-list-conc-matchp cstss "htab") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "htab"))))
Theorem:
(defthm imf-cst-htab-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%x9") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x9"))))
Theorem:
(defthm imf-cst-sp-conc-matching (implies (imf-cst-list-list-conc-matchp cstss "%x20") (and (equal (len cstss) 1) (imf-cst-list-rep-matchp (nth 0 cstss) "%x20"))))
Theorem:
(defthm imf-cst-quoted-pair-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( \"\\\" ( vchar / wsp ) )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( \"\\\" ( vchar / wsp ) )"))))
Theorem:
(defthm imf-cst-quoted-pair-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-qp") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-qp"))))
Theorem:
(defthm imf-cst-fws-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( [ *wsp crlf ] 1*wsp )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( [ *wsp crlf ] 1*wsp )"))))
Theorem:
(defthm imf-cst-fws-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-fws") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-fws"))))
Theorem:
(defthm imf-cst-ctext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d33-39") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d33-39"))))
Theorem:
(defthm imf-cst-ctext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d42-91") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d42-91"))))
Theorem:
(defthm imf-cst-ctext-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "%d93-126") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d93-126"))))
Theorem:
(defthm imf-cst-ctext-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-ctext") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-ctext"))))
Theorem:
(defthm imf-cst-ccontent-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "ctext") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "ctext"))))
Theorem:
(defthm imf-cst-ccontent-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm imf-cst-ccontent-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "comment") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "comment"))))
Theorem:
(defthm imf-cst-cfws-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( 1*( [ fws ] comment ) [ fws ] )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( 1*( [ fws ] comment ) [ fws ] )"))))
Theorem:
(defthm imf-cst-cfws-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "fws") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "fws"))))
Theorem:
(defthm imf-cst-atext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm imf-cst-atext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm imf-cst-atext-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "\"!\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"!\""))))
Theorem:
(defthm imf-cst-atext-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "\"#\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"#\""))))
Theorem:
(defthm imf-cst-atext-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "\"$\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"$\""))))
Theorem:
(defthm imf-cst-atext-conc6-rep-matching (implies (imf-cst-list-rep-matchp csts "\"%\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"%\""))))
Theorem:
(defthm imf-cst-atext-conc7-rep-matching (implies (imf-cst-list-rep-matchp csts "\"&\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"&\""))))
Theorem:
(defthm imf-cst-atext-conc8-rep-matching (implies (imf-cst-list-rep-matchp csts "\"'\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"'\""))))
Theorem:
(defthm imf-cst-atext-conc9-rep-matching (implies (imf-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm imf-cst-atext-conc10-rep-matching (implies (imf-cst-list-rep-matchp csts "\"+\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"+\""))))
Theorem:
(defthm imf-cst-atext-conc11-rep-matching (implies (imf-cst-list-rep-matchp csts "\"-\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"-\""))))
Theorem:
(defthm imf-cst-atext-conc12-rep-matching (implies (imf-cst-list-rep-matchp csts "\"/\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"/\""))))
Theorem:
(defthm imf-cst-atext-conc13-rep-matching (implies (imf-cst-list-rep-matchp csts "\"=\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"=\""))))
Theorem:
(defthm imf-cst-atext-conc14-rep-matching (implies (imf-cst-list-rep-matchp csts "\"?\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"?\""))))
Theorem:
(defthm imf-cst-atext-conc15-rep-matching (implies (imf-cst-list-rep-matchp csts "\"^\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"^\""))))
Theorem:
(defthm imf-cst-atext-conc16-rep-matching (implies (imf-cst-list-rep-matchp csts "\"_\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"_\""))))
Theorem:
(defthm imf-cst-atext-conc17-rep-matching (implies (imf-cst-list-rep-matchp csts "\"`\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"`\""))))
Theorem:
(defthm imf-cst-atext-conc18-rep-matching (implies (imf-cst-list-rep-matchp csts "\"{\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"{\""))))
Theorem:
(defthm imf-cst-atext-conc19-rep-matching (implies (imf-cst-list-rep-matchp csts "\"|\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"|\""))))
Theorem:
(defthm imf-cst-atext-conc20-rep-matching (implies (imf-cst-list-rep-matchp csts "\"}\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"}\""))))
Theorem:
(defthm imf-cst-atext-conc21-rep-matching (implies (imf-cst-list-rep-matchp csts "\"~\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"~\""))))
Theorem:
(defthm imf-cst-specials-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "\"(\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"(\""))))
Theorem:
(defthm imf-cst-specials-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "\")\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\")\""))))
Theorem:
(defthm imf-cst-specials-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "\"<\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"<\""))))
Theorem:
(defthm imf-cst-specials-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "\">\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\">\""))))
Theorem:
(defthm imf-cst-specials-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "\"[\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"[\""))))
Theorem:
(defthm imf-cst-specials-conc6-rep-matching (implies (imf-cst-list-rep-matchp csts "\"]\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"]\""))))
Theorem:
(defthm imf-cst-specials-conc7-rep-matching (implies (imf-cst-list-rep-matchp csts "\":\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\":\""))))
Theorem:
(defthm imf-cst-specials-conc8-rep-matching (implies (imf-cst-list-rep-matchp csts "\";\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\";\""))))
Theorem:
(defthm imf-cst-specials-conc9-rep-matching (implies (imf-cst-list-rep-matchp csts "\"@\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"@\""))))
Theorem:
(defthm imf-cst-specials-conc10-rep-matching (implies (imf-cst-list-rep-matchp csts "\"\\\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"\\\""))))
Theorem:
(defthm imf-cst-specials-conc11-rep-matching (implies (imf-cst-list-rep-matchp csts "\",\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\",\""))))
Theorem:
(defthm imf-cst-specials-conc12-rep-matching (implies (imf-cst-list-rep-matchp csts "\".\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\".\""))))
Theorem:
(defthm imf-cst-specials-conc13-rep-matching (implies (imf-cst-list-rep-matchp csts "dquote") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "dquote"))))
Theorem:
(defthm imf-cst-qtext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d33") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d33"))))
Theorem:
(defthm imf-cst-qtext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d35-91") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d35-91"))))
Theorem:
(defthm imf-cst-qtext-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "%d93-126") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d93-126"))))
Theorem:
(defthm imf-cst-qtext-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-qtext") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-qtext"))))
Theorem:
(defthm imf-cst-qcontent-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "qtext") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "qtext"))))
Theorem:
(defthm imf-cst-qcontent-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm imf-cst-word-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm imf-cst-word-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "quoted-string") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "quoted-string"))))
Theorem:
(defthm imf-cst-phrase-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-phrase") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-phrase"))))
Theorem:
(defthm imf-cst-unstructured-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( *( [ fws ] vchar ) *wsp )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( *( [ fws ] vchar ) *wsp )"))))
Theorem:
(defthm imf-cst-unstructured-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-unstruct") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-unstruct"))))
Theorem:
(defthm imf-cst-day-of-week-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( [ fws ] day-name )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( [ fws ] day-name )"))))
Theorem:
(defthm imf-cst-day-of-week-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-day-of-week") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-day-of-week"))))
Theorem:
(defthm imf-cst-day-name-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Mon\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Mon\""))))
Theorem:
(defthm imf-cst-day-name-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Tue\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Tue\""))))
Theorem:
(defthm imf-cst-day-name-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Wed\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Wed\""))))
Theorem:
(defthm imf-cst-day-name-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Thu\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Thu\""))))
Theorem:
(defthm imf-cst-day-name-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Fri\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Fri\""))))
Theorem:
(defthm imf-cst-day-name-conc6-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Sat\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Sat\""))))
Theorem:
(defthm imf-cst-day-name-conc7-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Sun\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Sun\""))))
Theorem:
(defthm imf-cst-day-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( [ fws ] 1*2digit fws )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( [ fws ] 1*2digit fws )"))))
Theorem:
(defthm imf-cst-day-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-day") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-day"))))
Theorem:
(defthm imf-cst-month-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Jan\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Jan\""))))
Theorem:
(defthm imf-cst-month-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Feb\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Feb\""))))
Theorem:
(defthm imf-cst-month-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Mar\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Mar\""))))
Theorem:
(defthm imf-cst-month-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Apr\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Apr\""))))
Theorem:
(defthm imf-cst-month-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "\"May\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"May\""))))
Theorem:
(defthm imf-cst-month-conc6-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Jun\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Jun\""))))
Theorem:
(defthm imf-cst-month-conc7-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Jul\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Jul\""))))
Theorem:
(defthm imf-cst-month-conc8-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Aug\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Aug\""))))
Theorem:
(defthm imf-cst-month-conc9-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Sep\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Sep\""))))
Theorem:
(defthm imf-cst-month-conc10-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Oct\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Oct\""))))
Theorem:
(defthm imf-cst-month-conc11-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Nov\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Nov\""))))
Theorem:
(defthm imf-cst-month-conc12-rep-matching (implies (imf-cst-list-rep-matchp csts "\"Dec\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"Dec\""))))
Theorem:
(defthm imf-cst-year-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( fws 4*digit fws )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( fws 4*digit fws )"))))
Theorem:
(defthm imf-cst-year-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-year") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-year"))))
Theorem:
(defthm imf-cst-hour-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-hour") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-hour"))))
Theorem:
(defthm imf-cst-minute-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-minute") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-minute"))))
Theorem:
(defthm imf-cst-second-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-second") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-second"))))
Theorem:
(defthm imf-cst-zone-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( fws ( \"+\" / \"-\" ) 4digit )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( fws ( \"+\" / \"-\" ) 4digit )"))))
Theorem:
(defthm imf-cst-zone-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-zone") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-zone"))))
Theorem:
(defthm imf-cst-address-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "mailbox") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "mailbox"))))
Theorem:
(defthm imf-cst-address-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "group") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "group"))))
Theorem:
(defthm imf-cst-mailbox-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "name-addr") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "name-addr"))))
Theorem:
(defthm imf-cst-mailbox-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "addr-spec") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "addr-spec"))))
Theorem:
(defthm imf-cst-angle-addr-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-angle-addr") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-angle-addr"))))
Theorem:
(defthm imf-cst-display-name-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "phrase") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "phrase"))))
Theorem:
(defthm imf-cst-mailbox-list-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( mailbox *( \",\" mailbox ) )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( mailbox *( \",\" mailbox ) )"))))
Theorem:
(defthm imf-cst-mailbox-list-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-mbox-list") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-mbox-list"))))
Theorem:
(defthm imf-cst-address-list-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( address *( \",\" address ) )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( address *( \",\" address ) )"))))
Theorem:
(defthm imf-cst-address-list-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-addr-list") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-addr-list"))))
Theorem:
(defthm imf-cst-group-list-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "mailbox-list") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "mailbox-list"))))
Theorem:
(defthm imf-cst-group-list-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "cfws") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "cfws"))))
Theorem:
(defthm imf-cst-group-list-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-group-list") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-group-list"))))
Theorem:
(defthm imf-cst-local-part-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "dot-atom") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "dot-atom"))))
Theorem:
(defthm imf-cst-local-part-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "quoted-string") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "quoted-string"))))
Theorem:
(defthm imf-cst-local-part-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-local-part") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-local-part"))))
Theorem:
(defthm imf-cst-domain-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "dot-atom") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "dot-atom"))))
Theorem:
(defthm imf-cst-domain-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "domain-literal") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "domain-literal"))))
Theorem:
(defthm imf-cst-domain-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-domain") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-domain"))))
Theorem:
(defthm imf-cst-dtext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d33-90") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d33-90"))))
Theorem:
(defthm imf-cst-dtext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d94-126") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d94-126"))))
Theorem:
(defthm imf-cst-dtext-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-dtext") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-dtext"))))
Theorem:
(defthm imf-cst-body-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "( *( *998text crlf ) *998text )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( *( *998text crlf ) *998text )"))))
Theorem:
(defthm imf-cst-body-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-body") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-body"))))
Theorem:
(defthm imf-cst-text-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d1-9") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d1-9"))))
Theorem:
(defthm imf-cst-text-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d11") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d11"))))
Theorem:
(defthm imf-cst-text-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "%d12") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d12"))))
Theorem:
(defthm imf-cst-text-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "%d14-127") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d14-127"))))
Theorem:
(defthm imf-cst-id-left-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "dot-atom-text") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-left-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-id-left") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-id-left"))))
Theorem:
(defthm imf-cst-id-right-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "dot-atom-text") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-right-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "no-fold-literal") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "no-fold-literal"))))
Theorem:
(defthm imf-cst-id-right-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-id-right") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-id-right"))))
Theorem:
(defthm imf-cst-path-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "angle-addr") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "angle-addr"))))
Theorem:
(defthm imf-cst-path-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "( [ cfws ] \"<\" [ cfws ] \">\" [ cfws ] )"))))
Theorem:
(defthm imf-cst-received-token-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "word") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "word"))))
Theorem:
(defthm imf-cst-received-token-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "angle-addr") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "angle-addr"))))
Theorem:
(defthm imf-cst-received-token-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "addr-spec") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "addr-spec"))))
Theorem:
(defthm imf-cst-received-token-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "domain") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "domain"))))
Theorem:
(defthm imf-cst-ftext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d33-57") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d33-57"))))
Theorem:
(defthm imf-cst-ftext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d59-126") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d59-126"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d1-8") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d1-8"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%d11") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d11"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "%d12") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d12"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "%d14-31") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d14-31"))))
Theorem:
(defthm imf-cst-obs-no-ws-ctl-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "%d127") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d127"))))
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-utext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%d0") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d0"))))
Theorem:
(defthm imf-cst-obs-utext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-utext-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "vchar") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "vchar"))))
Theorem:
(defthm imf-cst-obs-zone-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "\"UT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"UT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "\"GMT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"GMT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc3-rep-matching (implies (imf-cst-list-rep-matchp csts "\"EST\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"EST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc4-rep-matching (implies (imf-cst-list-rep-matchp csts "\"EDT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"EDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc5-rep-matching (implies (imf-cst-list-rep-matchp csts "\"CST\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"CST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc6-rep-matching (implies (imf-cst-list-rep-matchp csts "\"CDT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"CDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc7-rep-matching (implies (imf-cst-list-rep-matchp csts "\"MST\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"MST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc8-rep-matching (implies (imf-cst-list-rep-matchp csts "\"MDT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"MDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc9-rep-matching (implies (imf-cst-list-rep-matchp csts "\"PST\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"PST\""))))
Theorem:
(defthm imf-cst-obs-zone-conc10-rep-matching (implies (imf-cst-list-rep-matchp csts "\"PDT\"") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "\"PDT\""))))
Theorem:
(defthm imf-cst-obs-zone-conc11-rep-matching (implies (imf-cst-list-rep-matchp csts "%d65-73") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d65-73"))))
Theorem:
(defthm imf-cst-obs-zone-conc12-rep-matching (implies (imf-cst-list-rep-matchp csts "%d75-90") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d75-90"))))
Theorem:
(defthm imf-cst-obs-zone-conc13-rep-matching (implies (imf-cst-list-rep-matchp csts "%d97-105") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d97-105"))))
Theorem:
(defthm imf-cst-obs-zone-conc14-rep-matching (implies (imf-cst-list-rep-matchp csts "%d107-122") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%d107-122"))))
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "obs-no-ws-ctl") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "quoted-pair") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "quoted-pair"))))
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "local-part") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "local-part"))))
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "domain") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "domain"))))
Theorem:
(defthm imf-cst-alpha-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "%x41-5A") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x41-5A"))))
Theorem:
(defthm imf-cst-alpha-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "%x61-7A") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x61-7A"))))
Theorem:
(defthm imf-cst-cr-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%xD") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%xD"))))
Theorem:
(defthm imf-cst-digit-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%x30-39") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x30-39"))))
Theorem:
(defthm imf-cst-dquote-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%x22") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x22"))))
Theorem:
(defthm imf-cst-lf-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%xA") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%xA"))))
Theorem:
(defthm imf-cst-vchar-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%x21-7E") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x21-7E"))))
Theorem:
(defthm imf-cst-wsp-conc1-rep-matching (implies (imf-cst-list-rep-matchp csts "sp") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "sp"))))
Theorem:
(defthm imf-cst-wsp-conc2-rep-matching (implies (imf-cst-list-rep-matchp csts "htab") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "htab"))))
Theorem:
(defthm imf-cst-htab-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%x9") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x9"))))
Theorem:
(defthm imf-cst-sp-conc-rep-matching (implies (imf-cst-list-rep-matchp csts "%x20") (and (equal (len csts) 1) (imf-cst-matchp (nth 0 csts) "%x20"))))
Theorem:
(defthm imf-cst-ccontent-conc-equivs (implies (imf-cst-matchp cst "ccontent") (and (iff (imf-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 (imf-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 (imf-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 imf-cst-qcontent-conc-equivs (implies (imf-cst-matchp cst "qcontent") (and (iff (imf-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 (imf-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 imf-cst-word-conc-equivs (implies (imf-cst-matchp cst "word") (and (iff (imf-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 (imf-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 imf-cst-address-conc-equivs (implies (imf-cst-matchp cst "address") (and (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "mailbox") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "mailbox"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "group") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "group"))))))
Theorem:
(defthm imf-cst-mailbox-conc-equivs (implies (imf-cst-matchp cst "mailbox") (and (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name-addr") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name-addr"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "addr-spec") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "addr-spec"))))))
Theorem:
(defthm imf-cst-group-list-conc-equivs (implies (imf-cst-matchp cst "group-list") (and (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "mailbox-list") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "mailbox-list"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "cfws") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "cfws"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-group-list") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-group-list"))))))
Theorem:
(defthm imf-cst-local-part-conc-equivs (implies (imf-cst-matchp cst "local-part") (and (iff (imf-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 (imf-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"))) (iff (imf-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 imf-cst-domain-conc-equivs (implies (imf-cst-matchp cst "domain") (and (iff (imf-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 (imf-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 (imf-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 imf-cst-id-left-conc-equivs (implies (imf-cst-matchp cst "id-left") (and (iff (imf-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 (imf-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 imf-cst-id-right-conc-equivs (implies (imf-cst-matchp cst "id-right") (and (iff (imf-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 (imf-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 (imf-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 imf-cst-received-token-conc-equivs (implies (imf-cst-matchp cst "received-token") (and (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "word") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "word"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "angle-addr") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "angle-addr"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "addr-spec") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "addr-spec"))) (iff (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "domain") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "domain"))))))
Theorem:
(defthm imf-cst-obs-dtext-conc-equivs (implies (imf-cst-matchp cst "obs-dtext") (and (iff (imf-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 (imf-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 imf-cst-wsp-conc-equivs (implies (imf-cst-matchp cst "wsp") (and (iff (imf-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 (imf-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 imf-cst-ccontent-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "ccontent"))) (let ((__function__ 'imf-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-imf-cst-ccontent-conc? (b* ((number (imf-cst-ccontent-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc?-possibilities (b* ((number (imf-cst-ccontent-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-ccontent-conc? cst)))))
Theorem:
(defthm imf-cst-ccontent-conc?-of-tree-fix-cst (equal (imf-cst-ccontent-conc? (tree-fix cst)) (imf-cst-ccontent-conc? cst)))
Theorem:
(defthm imf-cst-ccontent-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc? cst) (imf-cst-ccontent-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-ccontent-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "ccontent") (iff (equal (imf-cst-ccontent-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ctext"))))
Theorem:
(defthm imf-cst-ccontent-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "ccontent") (iff (equal (imf-cst-ccontent-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Theorem:
(defthm imf-cst-ccontent-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "ccontent") (iff (equal (imf-cst-ccontent-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "comment"))))
Function:
(defun imf-cst-qcontent-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "qcontent"))) (let ((__function__ 'imf-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-imf-cst-qcontent-conc? (b* ((number (imf-cst-qcontent-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc?-possibilities (b* ((number (imf-cst-qcontent-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-qcontent-conc? cst)))))
Theorem:
(defthm imf-cst-qcontent-conc?-of-tree-fix-cst (equal (imf-cst-qcontent-conc? (tree-fix cst)) (imf-cst-qcontent-conc? cst)))
Theorem:
(defthm imf-cst-qcontent-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc? cst) (imf-cst-qcontent-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-qcontent-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "qcontent") (iff (equal (imf-cst-qcontent-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "qtext"))))
Theorem:
(defthm imf-cst-qcontent-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "qcontent") (iff (equal (imf-cst-qcontent-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Function:
(defun imf-cst-word-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "word"))) (let ((__function__ 'imf-cst-word-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-imf-cst-word-conc? (b* ((number (imf-cst-word-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc?-possibilities (b* ((number (imf-cst-word-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-word-conc? cst)))))
Theorem:
(defthm imf-cst-word-conc?-of-tree-fix-cst (equal (imf-cst-word-conc? (tree-fix cst)) (imf-cst-word-conc? cst)))
Theorem:
(defthm imf-cst-word-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc? cst) (imf-cst-word-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-word-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "word") (iff (equal (imf-cst-word-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom"))))
Theorem:
(defthm imf-cst-word-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "word") (iff (equal (imf-cst-word-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string"))))
Function:
(defun imf-cst-address-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "address"))) (let ((__function__ 'imf-cst-address-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "mailbox")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "group")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imf-cst-address-conc? (b* ((number (imf-cst-address-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc?-possibilities (b* ((number (imf-cst-address-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-address-conc? cst)))))
Theorem:
(defthm imf-cst-address-conc?-of-tree-fix-cst (equal (imf-cst-address-conc? (tree-fix cst)) (imf-cst-address-conc? cst)))
Theorem:
(defthm imf-cst-address-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc? cst) (imf-cst-address-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-address-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "address") (iff (equal (imf-cst-address-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "mailbox"))))
Theorem:
(defthm imf-cst-address-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "address") (iff (equal (imf-cst-address-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "group"))))
Function:
(defun imf-cst-mailbox-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "mailbox"))) (let ((__function__ 'imf-cst-mailbox-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name-addr")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "addr-spec")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imf-cst-mailbox-conc? (b* ((number (imf-cst-mailbox-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc?-possibilities (b* ((number (imf-cst-mailbox-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-mailbox-conc? cst)))))
Theorem:
(defthm imf-cst-mailbox-conc?-of-tree-fix-cst (equal (imf-cst-mailbox-conc? (tree-fix cst)) (imf-cst-mailbox-conc? cst)))
Theorem:
(defthm imf-cst-mailbox-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc? cst) (imf-cst-mailbox-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-mailbox-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "mailbox") (iff (equal (imf-cst-mailbox-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name-addr"))))
Theorem:
(defthm imf-cst-mailbox-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "mailbox") (iff (equal (imf-cst-mailbox-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "addr-spec"))))
Function:
(defun imf-cst-group-list-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "group-list"))) (let ((__function__ 'imf-cst-group-list-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "mailbox-list")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "cfws")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-group-list")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imf-cst-group-list-conc? (b* ((number (imf-cst-group-list-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc?-possibilities (b* ((number (imf-cst-group-list-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-group-list-conc? cst)))))
Theorem:
(defthm imf-cst-group-list-conc?-of-tree-fix-cst (equal (imf-cst-group-list-conc? (tree-fix cst)) (imf-cst-group-list-conc? cst)))
Theorem:
(defthm imf-cst-group-list-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc? cst) (imf-cst-group-list-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-group-list-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "group-list") (iff (equal (imf-cst-group-list-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "mailbox-list"))))
Theorem:
(defthm imf-cst-group-list-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "group-list") (iff (equal (imf-cst-group-list-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "cfws"))))
Theorem:
(defthm imf-cst-group-list-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "group-list") (iff (equal (imf-cst-group-list-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-group-list"))))
Function:
(defun imf-cst-local-part-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "local-part"))) (let ((__function__ 'imf-cst-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 "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-imf-cst-local-part-conc? (b* ((number (imf-cst-local-part-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc?-possibilities (b* ((number (imf-cst-local-part-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-local-part-conc? cst)))))
Theorem:
(defthm imf-cst-local-part-conc?-of-tree-fix-cst (equal (imf-cst-local-part-conc? (tree-fix cst)) (imf-cst-local-part-conc? cst)))
Theorem:
(defthm imf-cst-local-part-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc? cst) (imf-cst-local-part-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-local-part-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "local-part") (iff (equal (imf-cst-local-part-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom"))))
Theorem:
(defthm imf-cst-local-part-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "local-part") (iff (equal (imf-cst-local-part-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string"))))
Theorem:
(defthm imf-cst-local-part-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "local-part") (iff (equal (imf-cst-local-part-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-local-part"))))
Function:
(defun imf-cst-domain-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "domain"))) (let ((__function__ 'imf-cst-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-imf-cst-domain-conc? (b* ((number (imf-cst-domain-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc?-possibilities (b* ((number (imf-cst-domain-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-domain-conc? cst)))))
Theorem:
(defthm imf-cst-domain-conc?-of-tree-fix-cst (equal (imf-cst-domain-conc? (tree-fix cst)) (imf-cst-domain-conc? cst)))
Theorem:
(defthm imf-cst-domain-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc? cst) (imf-cst-domain-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-domain-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "domain") (iff (equal (imf-cst-domain-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom"))))
Theorem:
(defthm imf-cst-domain-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "domain") (iff (equal (imf-cst-domain-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "domain-literal"))))
Theorem:
(defthm imf-cst-domain-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "domain") (iff (equal (imf-cst-domain-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-domain"))))
Function:
(defun imf-cst-id-left-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "id-left"))) (let ((__function__ 'imf-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-imf-cst-id-left-conc? (b* ((number (imf-cst-id-left-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc?-possibilities (b* ((number (imf-cst-id-left-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-id-left-conc? cst)))))
Theorem:
(defthm imf-cst-id-left-conc?-of-tree-fix-cst (equal (imf-cst-id-left-conc? (tree-fix cst)) (imf-cst-id-left-conc? cst)))
Theorem:
(defthm imf-cst-id-left-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc? cst) (imf-cst-id-left-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-id-left-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "id-left") (iff (equal (imf-cst-id-left-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-left-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "id-left") (iff (equal (imf-cst-id-left-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-left"))))
Function:
(defun imf-cst-id-right-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "id-right"))) (let ((__function__ 'imf-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-imf-cst-id-right-conc? (b* ((number (imf-cst-id-right-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc?-possibilities (b* ((number (imf-cst-id-right-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-id-right-conc? cst)))))
Theorem:
(defthm imf-cst-id-right-conc?-of-tree-fix-cst (equal (imf-cst-id-right-conc? (tree-fix cst)) (imf-cst-id-right-conc? cst)))
Theorem:
(defthm imf-cst-id-right-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc? cst) (imf-cst-id-right-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-id-right-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "id-right") (iff (equal (imf-cst-id-right-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dot-atom-text"))))
Theorem:
(defthm imf-cst-id-right-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "id-right") (iff (equal (imf-cst-id-right-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "no-fold-literal"))))
Theorem:
(defthm imf-cst-id-right-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "id-right") (iff (equal (imf-cst-id-right-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-id-right"))))
Function:
(defun imf-cst-received-token-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "received-token"))) (let ((__function__ 'imf-cst-received-token-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "word")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "angle-addr")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "addr-spec")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "domain")) 4) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imf-cst-received-token-conc? (b* ((number (imf-cst-received-token-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc?-possibilities (b* ((number (imf-cst-received-token-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-received-token-conc? cst)))))
Theorem:
(defthm imf-cst-received-token-conc?-of-tree-fix-cst (equal (imf-cst-received-token-conc? (tree-fix cst)) (imf-cst-received-token-conc? cst)))
Theorem:
(defthm imf-cst-received-token-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc? cst) (imf-cst-received-token-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-received-token-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "received-token") (iff (equal (imf-cst-received-token-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "word"))))
Theorem:
(defthm imf-cst-received-token-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "received-token") (iff (equal (imf-cst-received-token-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "angle-addr"))))
Theorem:
(defthm imf-cst-received-token-conc?-3-iff-match-conc (implies (imf-cst-matchp cst "received-token") (iff (equal (imf-cst-received-token-conc? cst) 3) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "addr-spec"))))
Theorem:
(defthm imf-cst-received-token-conc?-4-iff-match-conc (implies (imf-cst-matchp cst "received-token") (iff (equal (imf-cst-received-token-conc? cst) 4) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "domain"))))
Function:
(defun imf-cst-obs-dtext-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-dtext"))) (let ((__function__ 'imf-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-imf-cst-obs-dtext-conc? (b* ((number (imf-cst-obs-dtext-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc?-possibilities (b* ((number (imf-cst-obs-dtext-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-obs-dtext-conc? cst)))))
Theorem:
(defthm imf-cst-obs-dtext-conc?-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc? (tree-fix cst)) (imf-cst-obs-dtext-conc? cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc? cst) (imf-cst-obs-dtext-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-obs-dtext-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "obs-dtext") (iff (equal (imf-cst-obs-dtext-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-no-ws-ctl"))))
Theorem:
(defthm imf-cst-obs-dtext-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "obs-dtext") (iff (equal (imf-cst-obs-dtext-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-pair"))))
Function:
(defun imf-cst-wsp-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "wsp"))) (let ((__function__ 'imf-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-imf-cst-wsp-conc? (b* ((number (imf-cst-wsp-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc?-possibilities (b* ((number (imf-cst-wsp-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imf-cst-wsp-conc? cst)))))
Theorem:
(defthm imf-cst-wsp-conc?-of-tree-fix-cst (equal (imf-cst-wsp-conc? (tree-fix cst)) (imf-cst-wsp-conc? cst)))
Theorem:
(defthm imf-cst-wsp-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc? cst) (imf-cst-wsp-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imf-cst-wsp-conc?-1-iff-match-conc (implies (imf-cst-matchp cst "wsp") (iff (equal (imf-cst-wsp-conc? cst) 1) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "sp"))))
Theorem:
(defthm imf-cst-wsp-conc?-2-iff-match-conc (implies (imf-cst-matchp cst "wsp") (iff (equal (imf-cst-wsp-conc? cst) 2) (imf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "htab"))))
Function:
(defun imf-cst-ccontent-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-ccontent-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-ccontent-conc1 (b* ((cstss (imf-cst-ccontent-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)) (b* ((cstss (imf-cst-ccontent-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-of-tree-fix-cst (equal (imf-cst-ccontent-conc1 (tree-fix cst)) (imf-cst-ccontent-conc1 cst)))
Theorem:
(defthm imf-cst-ccontent-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc1 cst) (imf-cst-ccontent-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-ccontent-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-ccontent-conc2 (b* ((cstss (imf-cst-ccontent-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)) (b* ((cstss (imf-cst-ccontent-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-of-tree-fix-cst (equal (imf-cst-ccontent-conc2 (tree-fix cst)) (imf-cst-ccontent-conc2 cst)))
Theorem:
(defthm imf-cst-ccontent-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc2 cst) (imf-cst-ccontent-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'imf-cst-ccontent-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-ccontent-conc3 (b* ((cstss (imf-cst-ccontent-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)) (b* ((cstss (imf-cst-ccontent-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "comment"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-of-tree-fix-cst (equal (imf-cst-ccontent-conc3 (tree-fix cst)) (imf-cst-ccontent-conc3 cst)))
Theorem:
(defthm imf-cst-ccontent-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc3 cst) (imf-cst-ccontent-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-comment-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "comment"))) (let ((__function__ 'imf-cst-comment-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-comment-conc (b* ((cstss (imf-cst-comment-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-comment-conc-match (implies (imf-cst-matchp cst "comment") (b* ((cstss (imf-cst-comment-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"(\" *( [ fws ] ccontent ) [ fws ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-comment-conc-of-tree-fix-cst (equal (imf-cst-comment-conc (tree-fix cst)) (imf-cst-comment-conc cst)))
Theorem:
(defthm imf-cst-comment-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-comment-conc cst) (imf-cst-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "atom"))) (let ((__function__ 'imf-cst-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-atom-conc (b* ((cstss (imf-cst-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-atom-conc-match (implies (imf-cst-matchp cst "atom") (b* ((cstss (imf-cst-atom-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 1*atext [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-atom-conc-of-tree-fix-cst (equal (imf-cst-atom-conc (tree-fix cst)) (imf-cst-atom-conc cst)))
Theorem:
(defthm imf-cst-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-atom-conc cst) (imf-cst-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-dot-atom-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "dot-atom-text"))) (let ((__function__ 'imf-cst-dot-atom-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-dot-atom-text-conc (b* ((cstss (imf-cst-dot-atom-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dot-atom-text-conc-match (implies (imf-cst-matchp cst "dot-atom-text") (b* ((cstss (imf-cst-dot-atom-text-conc cst))) (imf-cst-list-list-conc-matchp cstss "1*atext *( \".\" 1*atext )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dot-atom-text-conc-of-tree-fix-cst (equal (imf-cst-dot-atom-text-conc (tree-fix cst)) (imf-cst-dot-atom-text-conc cst)))
Theorem:
(defthm imf-cst-dot-atom-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-dot-atom-text-conc cst) (imf-cst-dot-atom-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-dot-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "dot-atom"))) (let ((__function__ 'imf-cst-dot-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-dot-atom-conc (b* ((cstss (imf-cst-dot-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dot-atom-conc-match (implies (imf-cst-matchp cst "dot-atom") (b* ((cstss (imf-cst-dot-atom-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] dot-atom-text [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dot-atom-conc-of-tree-fix-cst (equal (imf-cst-dot-atom-conc (tree-fix cst)) (imf-cst-dot-atom-conc cst)))
Theorem:
(defthm imf-cst-dot-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-dot-atom-conc cst) (imf-cst-dot-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-qcontent-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-qcontent-conc1 (b* ((cstss (imf-cst-qcontent-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)) (b* ((cstss (imf-cst-qcontent-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-of-tree-fix-cst (equal (imf-cst-qcontent-conc1 (tree-fix cst)) (imf-cst-qcontent-conc1 cst)))
Theorem:
(defthm imf-cst-qcontent-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc1 cst) (imf-cst-qcontent-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-qcontent-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-qcontent-conc2 (b* ((cstss (imf-cst-qcontent-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)) (b* ((cstss (imf-cst-qcontent-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-of-tree-fix-cst (equal (imf-cst-qcontent-conc2 (tree-fix cst)) (imf-cst-qcontent-conc2 cst)))
Theorem:
(defthm imf-cst-qcontent-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc2 cst) (imf-cst-qcontent-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-quoted-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "quoted-string"))) (let ((__function__ 'imf-cst-quoted-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-quoted-string-conc (b* ((cstss (imf-cst-quoted-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-quoted-string-conc-match (implies (imf-cst-matchp cst "quoted-string") (b* ((cstss (imf-cst-quoted-string-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-quoted-string-conc-of-tree-fix-cst (equal (imf-cst-quoted-string-conc (tree-fix cst)) (imf-cst-quoted-string-conc cst)))
Theorem:
(defthm imf-cst-quoted-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-quoted-string-conc cst) (imf-cst-quoted-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)))) (let ((__function__ 'imf-cst-word-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-word-conc1 (b* ((cstss (imf-cst-word-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)) (b* ((cstss (imf-cst-word-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-of-tree-fix-cst (equal (imf-cst-word-conc1 (tree-fix cst)) (imf-cst-word-conc1 cst)))
Theorem:
(defthm imf-cst-word-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc1 cst) (imf-cst-word-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)))) (let ((__function__ 'imf-cst-word-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-word-conc2 (b* ((cstss (imf-cst-word-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)) (b* ((cstss (imf-cst-word-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-of-tree-fix-cst (equal (imf-cst-word-conc2 (tree-fix cst)) (imf-cst-word-conc2 cst)))
Theorem:
(defthm imf-cst-word-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc2 cst) (imf-cst-word-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-date-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "date-time"))) (let ((__function__ 'imf-cst-date-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-date-time-conc (b* ((cstss (imf-cst-date-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-date-time-conc-match (implies (imf-cst-matchp cst "date-time") (b* ((cstss (imf-cst-date-time-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ day-of-week \",\" ] date time [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-date-time-conc-of-tree-fix-cst (equal (imf-cst-date-time-conc (tree-fix cst)) (imf-cst-date-time-conc cst)))
Theorem:
(defthm imf-cst-date-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-date-time-conc cst) (imf-cst-date-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "date"))) (let ((__function__ 'imf-cst-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-date-conc (b* ((cstss (imf-cst-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-date-conc-match (implies (imf-cst-matchp cst "date") (b* ((cstss (imf-cst-date-conc cst))) (imf-cst-list-list-conc-matchp cstss "day month year"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-date-conc-of-tree-fix-cst (equal (imf-cst-date-conc (tree-fix cst)) (imf-cst-date-conc cst)))
Theorem:
(defthm imf-cst-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-date-conc cst) (imf-cst-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "time"))) (let ((__function__ 'imf-cst-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-time-conc (b* ((cstss (imf-cst-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-time-conc-match (implies (imf-cst-matchp cst "time") (b* ((cstss (imf-cst-time-conc cst))) (imf-cst-list-list-conc-matchp cstss "time-of-day zone"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-time-conc-of-tree-fix-cst (equal (imf-cst-time-conc (tree-fix cst)) (imf-cst-time-conc cst)))
Theorem:
(defthm imf-cst-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-time-conc cst) (imf-cst-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-time-of-day-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "time-of-day"))) (let ((__function__ 'imf-cst-time-of-day-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-time-of-day-conc (b* ((cstss (imf-cst-time-of-day-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-time-of-day-conc-match (implies (imf-cst-matchp cst "time-of-day") (b* ((cstss (imf-cst-time-of-day-conc cst))) (imf-cst-list-list-conc-matchp cstss "hour \":\" minute [ \":\" second ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-time-of-day-conc-of-tree-fix-cst (equal (imf-cst-time-of-day-conc (tree-fix cst)) (imf-cst-time-of-day-conc cst)))
Theorem:
(defthm imf-cst-time-of-day-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-time-of-day-conc cst) (imf-cst-time-of-day-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)))) (let ((__function__ 'imf-cst-address-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-address-conc1 (b* ((cstss (imf-cst-address-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)) (b* ((cstss (imf-cst-address-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-of-tree-fix-cst (equal (imf-cst-address-conc1 (tree-fix cst)) (imf-cst-address-conc1 cst)))
Theorem:
(defthm imf-cst-address-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc1 cst) (imf-cst-address-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)))) (let ((__function__ 'imf-cst-address-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-address-conc2 (b* ((cstss (imf-cst-address-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)) (b* ((cstss (imf-cst-address-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "group"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-of-tree-fix-cst (equal (imf-cst-address-conc2 (tree-fix cst)) (imf-cst-address-conc2 cst)))
Theorem:
(defthm imf-cst-address-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc2 cst) (imf-cst-address-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)))) (let ((__function__ 'imf-cst-mailbox-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-mailbox-conc1 (b* ((cstss (imf-cst-mailbox-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)) (b* ((cstss (imf-cst-mailbox-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "name-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-of-tree-fix-cst (equal (imf-cst-mailbox-conc1 (tree-fix cst)) (imf-cst-mailbox-conc1 cst)))
Theorem:
(defthm imf-cst-mailbox-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc1 cst) (imf-cst-mailbox-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)))) (let ((__function__ 'imf-cst-mailbox-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-mailbox-conc2 (b* ((cstss (imf-cst-mailbox-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)) (b* ((cstss (imf-cst-mailbox-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-of-tree-fix-cst (equal (imf-cst-mailbox-conc2 (tree-fix cst)) (imf-cst-mailbox-conc2 cst)))
Theorem:
(defthm imf-cst-mailbox-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc2 cst) (imf-cst-mailbox-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-name-addr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "name-addr"))) (let ((__function__ 'imf-cst-name-addr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-name-addr-conc (b* ((cstss (imf-cst-name-addr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-name-addr-conc-match (implies (imf-cst-matchp cst "name-addr") (b* ((cstss (imf-cst-name-addr-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ display-name ] angle-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-name-addr-conc-of-tree-fix-cst (equal (imf-cst-name-addr-conc (tree-fix cst)) (imf-cst-name-addr-conc cst)))
Theorem:
(defthm imf-cst-name-addr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-name-addr-conc cst) (imf-cst-name-addr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "group"))) (let ((__function__ 'imf-cst-group-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-group-conc (b* ((cstss (imf-cst-group-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-conc-match (implies (imf-cst-matchp cst "group") (b* ((cstss (imf-cst-group-conc cst))) (imf-cst-list-list-conc-matchp cstss "display-name \":\" [ group-list ] \";\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-conc-of-tree-fix-cst (equal (imf-cst-group-conc (tree-fix cst)) (imf-cst-group-conc cst)))
Theorem:
(defthm imf-cst-group-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-conc cst) (imf-cst-group-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-display-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "display-name"))) (let ((__function__ 'imf-cst-display-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-display-name-conc (b* ((cstss (imf-cst-display-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-match (implies (imf-cst-matchp cst "display-name") (b* ((cstss (imf-cst-display-name-conc cst))) (imf-cst-list-list-conc-matchp cstss "phrase"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-of-tree-fix-cst (equal (imf-cst-display-name-conc (tree-fix cst)) (imf-cst-display-name-conc cst)))
Theorem:
(defthm imf-cst-display-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-display-name-conc cst) (imf-cst-display-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)))) (let ((__function__ 'imf-cst-group-list-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-group-list-conc1 (b* ((cstss (imf-cst-group-list-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)) (b* ((cstss (imf-cst-group-list-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "mailbox-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-of-tree-fix-cst (equal (imf-cst-group-list-conc1 (tree-fix cst)) (imf-cst-group-list-conc1 cst)))
Theorem:
(defthm imf-cst-group-list-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc1 cst) (imf-cst-group-list-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)))) (let ((__function__ 'imf-cst-group-list-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-group-list-conc2 (b* ((cstss (imf-cst-group-list-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)) (b* ((cstss (imf-cst-group-list-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "cfws"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-of-tree-fix-cst (equal (imf-cst-group-list-conc2 (tree-fix cst)) (imf-cst-group-list-conc2 cst)))
Theorem:
(defthm imf-cst-group-list-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc2 cst) (imf-cst-group-list-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)))) (let ((__function__ 'imf-cst-group-list-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-group-list-conc3 (b* ((cstss (imf-cst-group-list-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)) (b* ((cstss (imf-cst-group-list-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "obs-group-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-of-tree-fix-cst (equal (imf-cst-group-list-conc3 (tree-fix cst)) (imf-cst-group-list-conc3 cst)))
Theorem:
(defthm imf-cst-group-list-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc3 cst) (imf-cst-group-list-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-addr-spec-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "addr-spec"))) (let ((__function__ 'imf-cst-addr-spec-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-addr-spec-conc (b* ((cstss (imf-cst-addr-spec-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-addr-spec-conc-match (implies (imf-cst-matchp cst "addr-spec") (b* ((cstss (imf-cst-addr-spec-conc cst))) (imf-cst-list-list-conc-matchp cstss "local-part \"@\" domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-addr-spec-conc-of-tree-fix-cst (equal (imf-cst-addr-spec-conc (tree-fix cst)) (imf-cst-addr-spec-conc cst)))
Theorem:
(defthm imf-cst-addr-spec-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-addr-spec-conc cst) (imf-cst-addr-spec-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)))) (let ((__function__ 'imf-cst-local-part-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-local-part-conc1 (b* ((cstss (imf-cst-local-part-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)) (b* ((cstss (imf-cst-local-part-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-of-tree-fix-cst (equal (imf-cst-local-part-conc1 (tree-fix cst)) (imf-cst-local-part-conc1 cst)))
Theorem:
(defthm imf-cst-local-part-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc1 cst) (imf-cst-local-part-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)))) (let ((__function__ 'imf-cst-local-part-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-local-part-conc2 (b* ((cstss (imf-cst-local-part-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)) (b* ((cstss (imf-cst-local-part-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-of-tree-fix-cst (equal (imf-cst-local-part-conc2 (tree-fix cst)) (imf-cst-local-part-conc2 cst)))
Theorem:
(defthm imf-cst-local-part-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc2 cst) (imf-cst-local-part-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)))) (let ((__function__ 'imf-cst-local-part-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-local-part-conc3 (b* ((cstss (imf-cst-local-part-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)) (b* ((cstss (imf-cst-local-part-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-of-tree-fix-cst (equal (imf-cst-local-part-conc3 (tree-fix cst)) (imf-cst-local-part-conc3 cst)))
Theorem:
(defthm imf-cst-local-part-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc3 cst) (imf-cst-local-part-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)))) (let ((__function__ 'imf-cst-domain-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-domain-conc1 (b* ((cstss (imf-cst-domain-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)) (b* ((cstss (imf-cst-domain-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-of-tree-fix-cst (equal (imf-cst-domain-conc1 (tree-fix cst)) (imf-cst-domain-conc1 cst)))
Theorem:
(defthm imf-cst-domain-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc1 cst) (imf-cst-domain-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)))) (let ((__function__ 'imf-cst-domain-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-domain-conc2 (b* ((cstss (imf-cst-domain-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)) (b* ((cstss (imf-cst-domain-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-of-tree-fix-cst (equal (imf-cst-domain-conc2 (tree-fix cst)) (imf-cst-domain-conc2 cst)))
Theorem:
(defthm imf-cst-domain-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc2 cst) (imf-cst-domain-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)))) (let ((__function__ 'imf-cst-domain-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-domain-conc3 (b* ((cstss (imf-cst-domain-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)) (b* ((cstss (imf-cst-domain-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-of-tree-fix-cst (equal (imf-cst-domain-conc3 (tree-fix cst)) (imf-cst-domain-conc3 cst)))
Theorem:
(defthm imf-cst-domain-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc3 cst) (imf-cst-domain-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "domain-literal"))) (let ((__function__ 'imf-cst-domain-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-domain-literal-conc (b* ((cstss (imf-cst-domain-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-literal-conc-match (implies (imf-cst-matchp cst "domain-literal") (b* ((cstss (imf-cst-domain-literal-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-literal-conc-of-tree-fix-cst (equal (imf-cst-domain-literal-conc (tree-fix cst)) (imf-cst-domain-literal-conc cst)))
Theorem:
(defthm imf-cst-domain-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-literal-conc cst) (imf-cst-domain-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-message-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "message"))) (let ((__function__ 'imf-cst-message-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-message-conc (b* ((cstss (imf-cst-message-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-message-conc-match (implies (imf-cst-matchp cst "message") (b* ((cstss (imf-cst-message-conc cst))) (imf-cst-list-list-conc-matchp cstss "( fields / obs-fields ) [ crlf body ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-message-conc-of-tree-fix-cst (equal (imf-cst-message-conc (tree-fix cst)) (imf-cst-message-conc cst)))
Theorem:
(defthm imf-cst-message-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-message-conc cst) (imf-cst-message-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-fields-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "fields"))) (let ((__function__ 'imf-cst-fields-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-fields-conc (b* ((cstss (imf-cst-fields-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-fields-conc-match (implies (imf-cst-matchp cst "fields") (b* ((cstss (imf-cst-fields-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( trace *optional-field / *( resent-date / resent-from / resent-sender / resent-to / resent-cc / resent-bcc / resent-msg-id ) ) *( orig-date / from / sender / reply-to / to / cc / bcc / message-id / in-reply-to / references / subject / comments / keywords / optional-field )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-fields-conc-of-tree-fix-cst (equal (imf-cst-fields-conc (tree-fix cst)) (imf-cst-fields-conc cst)))
Theorem:
(defthm imf-cst-fields-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-fields-conc cst) (imf-cst-fields-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-orig-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "orig-date"))) (let ((__function__ 'imf-cst-orig-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-orig-date-conc (b* ((cstss (imf-cst-orig-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-orig-date-conc-match (implies (imf-cst-matchp cst "orig-date") (b* ((cstss (imf-cst-orig-date-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Date:\" date-time crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-orig-date-conc-of-tree-fix-cst (equal (imf-cst-orig-date-conc (tree-fix cst)) (imf-cst-orig-date-conc cst)))
Theorem:
(defthm imf-cst-orig-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-orig-date-conc cst) (imf-cst-orig-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-from-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "from"))) (let ((__function__ 'imf-cst-from-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-from-conc (b* ((cstss (imf-cst-from-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-from-conc-match (implies (imf-cst-matchp cst "from") (b* ((cstss (imf-cst-from-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"From:\" mailbox-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-from-conc-of-tree-fix-cst (equal (imf-cst-from-conc (tree-fix cst)) (imf-cst-from-conc cst)))
Theorem:
(defthm imf-cst-from-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-from-conc cst) (imf-cst-from-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-sender-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "sender"))) (let ((__function__ 'imf-cst-sender-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-sender-conc (b* ((cstss (imf-cst-sender-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sender-conc-match (implies (imf-cst-matchp cst "sender") (b* ((cstss (imf-cst-sender-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Sender:\" mailbox crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sender-conc-of-tree-fix-cst (equal (imf-cst-sender-conc (tree-fix cst)) (imf-cst-sender-conc cst)))
Theorem:
(defthm imf-cst-sender-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-sender-conc cst) (imf-cst-sender-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-reply-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "reply-to"))) (let ((__function__ 'imf-cst-reply-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-reply-to-conc (b* ((cstss (imf-cst-reply-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-reply-to-conc-match (implies (imf-cst-matchp cst "reply-to") (b* ((cstss (imf-cst-reply-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Reply-To:\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-reply-to-conc-of-tree-fix-cst (equal (imf-cst-reply-to-conc (tree-fix cst)) (imf-cst-reply-to-conc cst)))
Theorem:
(defthm imf-cst-reply-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-reply-to-conc cst) (imf-cst-reply-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "to"))) (let ((__function__ 'imf-cst-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-to-conc (b* ((cstss (imf-cst-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-to-conc-match (implies (imf-cst-matchp cst "to") (b* ((cstss (imf-cst-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"To:\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-to-conc-of-tree-fix-cst (equal (imf-cst-to-conc (tree-fix cst)) (imf-cst-to-conc cst)))
Theorem:
(defthm imf-cst-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-to-conc cst) (imf-cst-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-cc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "cc"))) (let ((__function__ 'imf-cst-cc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-cc-conc (b* ((cstss (imf-cst-cc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cc-conc-match (implies (imf-cst-matchp cst "cc") (b* ((cstss (imf-cst-cc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Cc:\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cc-conc-of-tree-fix-cst (equal (imf-cst-cc-conc (tree-fix cst)) (imf-cst-cc-conc cst)))
Theorem:
(defthm imf-cst-cc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-cc-conc cst) (imf-cst-cc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-bcc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "bcc"))) (let ((__function__ 'imf-cst-bcc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-bcc-conc (b* ((cstss (imf-cst-bcc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-bcc-conc-match (implies (imf-cst-matchp cst "bcc") (b* ((cstss (imf-cst-bcc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Bcc:\" [ address-list / cfws ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-bcc-conc-of-tree-fix-cst (equal (imf-cst-bcc-conc (tree-fix cst)) (imf-cst-bcc-conc cst)))
Theorem:
(defthm imf-cst-bcc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-bcc-conc cst) (imf-cst-bcc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-message-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "message-id"))) (let ((__function__ 'imf-cst-message-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-message-id-conc (b* ((cstss (imf-cst-message-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-message-id-conc-match (implies (imf-cst-matchp cst "message-id") (b* ((cstss (imf-cst-message-id-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Message-ID:\" msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-message-id-conc-of-tree-fix-cst (equal (imf-cst-message-id-conc (tree-fix cst)) (imf-cst-message-id-conc cst)))
Theorem:
(defthm imf-cst-message-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-message-id-conc cst) (imf-cst-message-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-in-reply-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "in-reply-to"))) (let ((__function__ 'imf-cst-in-reply-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-in-reply-to-conc (b* ((cstss (imf-cst-in-reply-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-in-reply-to-conc-match (implies (imf-cst-matchp cst "in-reply-to") (b* ((cstss (imf-cst-in-reply-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"In-Reply-To:\" 1*msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-in-reply-to-conc-of-tree-fix-cst (equal (imf-cst-in-reply-to-conc (tree-fix cst)) (imf-cst-in-reply-to-conc cst)))
Theorem:
(defthm imf-cst-in-reply-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-in-reply-to-conc cst) (imf-cst-in-reply-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-references-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "references"))) (let ((__function__ 'imf-cst-references-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-references-conc (b* ((cstss (imf-cst-references-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-references-conc-match (implies (imf-cst-matchp cst "references") (b* ((cstss (imf-cst-references-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"References:\" 1*msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-references-conc-of-tree-fix-cst (equal (imf-cst-references-conc (tree-fix cst)) (imf-cst-references-conc cst)))
Theorem:
(defthm imf-cst-references-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-references-conc cst) (imf-cst-references-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-msg-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "msg-id"))) (let ((__function__ 'imf-cst-msg-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-msg-id-conc (b* ((cstss (imf-cst-msg-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-msg-id-conc-match (implies (imf-cst-matchp cst "msg-id") (b* ((cstss (imf-cst-msg-id-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-msg-id-conc-of-tree-fix-cst (equal (imf-cst-msg-id-conc (tree-fix cst)) (imf-cst-msg-id-conc cst)))
Theorem:
(defthm imf-cst-msg-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-msg-id-conc cst) (imf-cst-msg-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-left-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-id-left-conc1 (b* ((cstss (imf-cst-id-left-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)) (b* ((cstss (imf-cst-id-left-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-of-tree-fix-cst (equal (imf-cst-id-left-conc1 (tree-fix cst)) (imf-cst-id-left-conc1 cst)))
Theorem:
(defthm imf-cst-id-left-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc1 cst) (imf-cst-id-left-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-left-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-id-left-conc2 (b* ((cstss (imf-cst-id-left-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)) (b* ((cstss (imf-cst-id-left-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-of-tree-fix-cst (equal (imf-cst-id-left-conc2 (tree-fix cst)) (imf-cst-id-left-conc2 cst)))
Theorem:
(defthm imf-cst-id-left-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc2 cst) (imf-cst-id-left-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-right-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-id-right-conc1 (b* ((cstss (imf-cst-id-right-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)) (b* ((cstss (imf-cst-id-right-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-of-tree-fix-cst (equal (imf-cst-id-right-conc1 (tree-fix cst)) (imf-cst-id-right-conc1 cst)))
Theorem:
(defthm imf-cst-id-right-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc1 cst) (imf-cst-id-right-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-right-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-id-right-conc2 (b* ((cstss (imf-cst-id-right-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)) (b* ((cstss (imf-cst-id-right-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-of-tree-fix-cst (equal (imf-cst-id-right-conc2 (tree-fix cst)) (imf-cst-id-right-conc2 cst)))
Theorem:
(defthm imf-cst-id-right-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc2 cst) (imf-cst-id-right-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)))) (let ((__function__ 'imf-cst-id-right-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-id-right-conc3 (b* ((cstss (imf-cst-id-right-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)) (b* ((cstss (imf-cst-id-right-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-of-tree-fix-cst (equal (imf-cst-id-right-conc3 (tree-fix cst)) (imf-cst-id-right-conc3 cst)))
Theorem:
(defthm imf-cst-id-right-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc3 cst) (imf-cst-id-right-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-no-fold-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "no-fold-literal"))) (let ((__function__ 'imf-cst-no-fold-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-no-fold-literal-conc (b* ((cstss (imf-cst-no-fold-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-no-fold-literal-conc-match (implies (imf-cst-matchp cst "no-fold-literal") (b* ((cstss (imf-cst-no-fold-literal-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-no-fold-literal-conc-of-tree-fix-cst (equal (imf-cst-no-fold-literal-conc (tree-fix cst)) (imf-cst-no-fold-literal-conc cst)))
Theorem:
(defthm imf-cst-no-fold-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-no-fold-literal-conc cst) (imf-cst-no-fold-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-subject-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "subject"))) (let ((__function__ 'imf-cst-subject-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-subject-conc (b* ((cstss (imf-cst-subject-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-subject-conc-match (implies (imf-cst-matchp cst "subject") (b* ((cstss (imf-cst-subject-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Subject:\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-subject-conc-of-tree-fix-cst (equal (imf-cst-subject-conc (tree-fix cst)) (imf-cst-subject-conc cst)))
Theorem:
(defthm imf-cst-subject-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-subject-conc cst) (imf-cst-subject-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-comments-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "comments"))) (let ((__function__ 'imf-cst-comments-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-comments-conc (b* ((cstss (imf-cst-comments-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-comments-conc-match (implies (imf-cst-matchp cst "comments") (b* ((cstss (imf-cst-comments-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Comments:\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-comments-conc-of-tree-fix-cst (equal (imf-cst-comments-conc (tree-fix cst)) (imf-cst-comments-conc cst)))
Theorem:
(defthm imf-cst-comments-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-comments-conc cst) (imf-cst-comments-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-keywords-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "keywords"))) (let ((__function__ 'imf-cst-keywords-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-keywords-conc (b* ((cstss (imf-cst-keywords-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-keywords-conc-match (implies (imf-cst-matchp cst "keywords") (b* ((cstss (imf-cst-keywords-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Keywords:\" phrase *( \",\" phrase ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-keywords-conc-of-tree-fix-cst (equal (imf-cst-keywords-conc (tree-fix cst)) (imf-cst-keywords-conc cst)))
Theorem:
(defthm imf-cst-keywords-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-keywords-conc cst) (imf-cst-keywords-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-date"))) (let ((__function__ 'imf-cst-resent-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-date-conc (b* ((cstss (imf-cst-resent-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-date-conc-match (implies (imf-cst-matchp cst "resent-date") (b* ((cstss (imf-cst-resent-date-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Date:\" date-time crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-date-conc-of-tree-fix-cst (equal (imf-cst-resent-date-conc (tree-fix cst)) (imf-cst-resent-date-conc cst)))
Theorem:
(defthm imf-cst-resent-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-date-conc cst) (imf-cst-resent-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-from-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-from"))) (let ((__function__ 'imf-cst-resent-from-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-from-conc (b* ((cstss (imf-cst-resent-from-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-from-conc-match (implies (imf-cst-matchp cst "resent-from") (b* ((cstss (imf-cst-resent-from-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-From:\" mailbox-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-from-conc-of-tree-fix-cst (equal (imf-cst-resent-from-conc (tree-fix cst)) (imf-cst-resent-from-conc cst)))
Theorem:
(defthm imf-cst-resent-from-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-from-conc cst) (imf-cst-resent-from-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-sender-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-sender"))) (let ((__function__ 'imf-cst-resent-sender-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-sender-conc (b* ((cstss (imf-cst-resent-sender-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-sender-conc-match (implies (imf-cst-matchp cst "resent-sender") (b* ((cstss (imf-cst-resent-sender-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Sender:\" mailbox crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-sender-conc-of-tree-fix-cst (equal (imf-cst-resent-sender-conc (tree-fix cst)) (imf-cst-resent-sender-conc cst)))
Theorem:
(defthm imf-cst-resent-sender-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-sender-conc cst) (imf-cst-resent-sender-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-to"))) (let ((__function__ 'imf-cst-resent-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-to-conc (b* ((cstss (imf-cst-resent-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-to-conc-match (implies (imf-cst-matchp cst "resent-to") (b* ((cstss (imf-cst-resent-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-To:\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-to-conc-of-tree-fix-cst (equal (imf-cst-resent-to-conc (tree-fix cst)) (imf-cst-resent-to-conc cst)))
Theorem:
(defthm imf-cst-resent-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-to-conc cst) (imf-cst-resent-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-cc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-cc"))) (let ((__function__ 'imf-cst-resent-cc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-cc-conc (b* ((cstss (imf-cst-resent-cc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-cc-conc-match (implies (imf-cst-matchp cst "resent-cc") (b* ((cstss (imf-cst-resent-cc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Cc:\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-cc-conc-of-tree-fix-cst (equal (imf-cst-resent-cc-conc (tree-fix cst)) (imf-cst-resent-cc-conc cst)))
Theorem:
(defthm imf-cst-resent-cc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-cc-conc cst) (imf-cst-resent-cc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-bcc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-bcc"))) (let ((__function__ 'imf-cst-resent-bcc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-bcc-conc (b* ((cstss (imf-cst-resent-bcc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-bcc-conc-match (implies (imf-cst-matchp cst "resent-bcc") (b* ((cstss (imf-cst-resent-bcc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Bcc:\" [ address-list / cfws ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-bcc-conc-of-tree-fix-cst (equal (imf-cst-resent-bcc-conc (tree-fix cst)) (imf-cst-resent-bcc-conc cst)))
Theorem:
(defthm imf-cst-resent-bcc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-bcc-conc cst) (imf-cst-resent-bcc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-resent-msg-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "resent-msg-id"))) (let ((__function__ 'imf-cst-resent-msg-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-resent-msg-id-conc (b* ((cstss (imf-cst-resent-msg-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-msg-id-conc-match (implies (imf-cst-matchp cst "resent-msg-id") (b* ((cstss (imf-cst-resent-msg-id-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Message-ID:\" msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-resent-msg-id-conc-of-tree-fix-cst (equal (imf-cst-resent-msg-id-conc (tree-fix cst)) (imf-cst-resent-msg-id-conc cst)))
Theorem:
(defthm imf-cst-resent-msg-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-resent-msg-id-conc cst) (imf-cst-resent-msg-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-trace-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "trace"))) (let ((__function__ 'imf-cst-trace-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-trace-conc (b* ((cstss (imf-cst-trace-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-trace-conc-match (implies (imf-cst-matchp cst "trace") (b* ((cstss (imf-cst-trace-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ return ] 1*received"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-trace-conc-of-tree-fix-cst (equal (imf-cst-trace-conc (tree-fix cst)) (imf-cst-trace-conc cst)))
Theorem:
(defthm imf-cst-trace-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-trace-conc cst) (imf-cst-trace-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-return-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "return"))) (let ((__function__ 'imf-cst-return-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-return-conc (b* ((cstss (imf-cst-return-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-return-conc-match (implies (imf-cst-matchp cst "return") (b* ((cstss (imf-cst-return-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Return-Path:\" path crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-return-conc-of-tree-fix-cst (equal (imf-cst-return-conc (tree-fix cst)) (imf-cst-return-conc cst)))
Theorem:
(defthm imf-cst-return-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-return-conc cst) (imf-cst-return-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "received"))) (let ((__function__ 'imf-cst-received-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-received-conc (b* ((cstss (imf-cst-received-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-conc-match (implies (imf-cst-matchp cst "received") (b* ((cstss (imf-cst-received-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Received:\" *received-token \";\" date-time crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-conc-of-tree-fix-cst (equal (imf-cst-received-conc (tree-fix cst)) (imf-cst-received-conc cst)))
Theorem:
(defthm imf-cst-received-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-conc cst) (imf-cst-received-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)))) (let ((__function__ 'imf-cst-received-token-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-received-token-conc1 (b* ((cstss (imf-cst-received-token-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)) (b* ((cstss (imf-cst-received-token-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "word"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-of-tree-fix-cst (equal (imf-cst-received-token-conc1 (tree-fix cst)) (imf-cst-received-token-conc1 cst)))
Theorem:
(defthm imf-cst-received-token-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc1 cst) (imf-cst-received-token-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)))) (let ((__function__ 'imf-cst-received-token-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-received-token-conc2 (b* ((cstss (imf-cst-received-token-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)) (b* ((cstss (imf-cst-received-token-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "angle-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-of-tree-fix-cst (equal (imf-cst-received-token-conc2 (tree-fix cst)) (imf-cst-received-token-conc2 cst)))
Theorem:
(defthm imf-cst-received-token-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc2 cst) (imf-cst-received-token-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)))) (let ((__function__ 'imf-cst-received-token-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-received-token-conc3 (b* ((cstss (imf-cst-received-token-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)) (b* ((cstss (imf-cst-received-token-conc3 cst))) (imf-cst-list-list-conc-matchp cstss "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-of-tree-fix-cst (equal (imf-cst-received-token-conc3 (tree-fix cst)) (imf-cst-received-token-conc3 cst)))
Theorem:
(defthm imf-cst-received-token-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc3 cst) (imf-cst-received-token-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)))) (let ((__function__ 'imf-cst-received-token-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-received-token-conc4 (b* ((cstss (imf-cst-received-token-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)) (b* ((cstss (imf-cst-received-token-conc4 cst))) (imf-cst-list-list-conc-matchp cstss "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-of-tree-fix-cst (equal (imf-cst-received-token-conc4 (tree-fix cst)) (imf-cst-received-token-conc4 cst)))
Theorem:
(defthm imf-cst-received-token-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc4 cst) (imf-cst-received-token-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-optional-field-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "optional-field"))) (let ((__function__ 'imf-cst-optional-field-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-optional-field-conc (b* ((cstss (imf-cst-optional-field-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-optional-field-conc-match (implies (imf-cst-matchp cst "optional-field") (b* ((cstss (imf-cst-optional-field-conc cst))) (imf-cst-list-list-conc-matchp cstss "field-name \":\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-optional-field-conc-of-tree-fix-cst (equal (imf-cst-optional-field-conc (tree-fix cst)) (imf-cst-optional-field-conc cst)))
Theorem:
(defthm imf-cst-optional-field-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-optional-field-conc cst) (imf-cst-optional-field-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-field-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "field-name"))) (let ((__function__ 'imf-cst-field-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-field-name-conc (b* ((cstss (imf-cst-field-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-field-name-conc-match (implies (imf-cst-matchp cst "field-name") (b* ((cstss (imf-cst-field-name-conc cst))) (imf-cst-list-list-conc-matchp cstss "1*ftext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-field-name-conc-of-tree-fix-cst (equal (imf-cst-field-name-conc (tree-fix cst)) (imf-cst-field-name-conc cst)))
Theorem:
(defthm imf-cst-field-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-field-name-conc cst) (imf-cst-field-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-ctext-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-ctext"))) (let ((__function__ 'imf-cst-obs-ctext-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-ctext-conc (b* ((cstss (imf-cst-obs-ctext-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-match (implies (imf-cst-matchp cst "obs-ctext") (b* ((cstss (imf-cst-obs-ctext-conc cst))) (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-of-tree-fix-cst (equal (imf-cst-obs-ctext-conc (tree-fix cst)) (imf-cst-obs-ctext-conc cst)))
Theorem:
(defthm imf-cst-obs-ctext-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-ctext-conc cst) (imf-cst-obs-ctext-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-qtext-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-qtext"))) (let ((__function__ 'imf-cst-obs-qtext-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-qtext-conc (b* ((cstss (imf-cst-obs-qtext-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-match (implies (imf-cst-matchp cst "obs-qtext") (b* ((cstss (imf-cst-obs-qtext-conc cst))) (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-of-tree-fix-cst (equal (imf-cst-obs-qtext-conc (tree-fix cst)) (imf-cst-obs-qtext-conc cst)))
Theorem:
(defthm imf-cst-obs-qtext-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-qtext-conc cst) (imf-cst-obs-qtext-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-qp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-qp"))) (let ((__function__ 'imf-cst-obs-qp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-qp-conc (b* ((cstss (imf-cst-obs-qp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qp-conc-match (implies (imf-cst-matchp cst "obs-qp") (b* ((cstss (imf-cst-obs-qp-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qp-conc-of-tree-fix-cst (equal (imf-cst-obs-qp-conc (tree-fix cst)) (imf-cst-obs-qp-conc cst)))
Theorem:
(defthm imf-cst-obs-qp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-qp-conc cst) (imf-cst-obs-qp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-body-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-body"))) (let ((__function__ 'imf-cst-obs-body-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-body-conc (b* ((cstss (imf-cst-obs-body-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-body-conc-match (implies (imf-cst-matchp cst "obs-body") (b* ((cstss (imf-cst-obs-body-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( ( %d0 / text ) *lf *cr ) ) / crlf )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-body-conc-of-tree-fix-cst (equal (imf-cst-obs-body-conc (tree-fix cst)) (imf-cst-obs-body-conc cst)))
Theorem:
(defthm imf-cst-obs-body-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-body-conc cst) (imf-cst-obs-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-unstruct-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-unstruct"))) (let ((__function__ 'imf-cst-obs-unstruct-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-unstruct-conc (b* ((cstss (imf-cst-obs-unstruct-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-unstruct-conc-match (implies (imf-cst-matchp cst "obs-unstruct") (b* ((cstss (imf-cst-obs-unstruct-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( ( *lf *cr *( obs-utext *lf *cr ) ) / fws )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-unstruct-conc-of-tree-fix-cst (equal (imf-cst-obs-unstruct-conc (tree-fix cst)) (imf-cst-obs-unstruct-conc cst)))
Theorem:
(defthm imf-cst-obs-unstruct-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-unstruct-conc cst) (imf-cst-obs-unstruct-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-phrase-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-phrase"))) (let ((__function__ 'imf-cst-obs-phrase-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-phrase-conc (b* ((cstss (imf-cst-obs-phrase-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-phrase-conc-match (implies (imf-cst-matchp cst "obs-phrase") (b* ((cstss (imf-cst-obs-phrase-conc cst))) (imf-cst-list-list-conc-matchp cstss "word *( word / \".\" / cfws )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-phrase-conc-of-tree-fix-cst (equal (imf-cst-obs-phrase-conc (tree-fix cst)) (imf-cst-obs-phrase-conc cst)))
Theorem:
(defthm imf-cst-obs-phrase-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-phrase-conc cst) (imf-cst-obs-phrase-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-phrase-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-phrase-list"))) (let ((__function__ 'imf-cst-obs-phrase-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-phrase-list-conc (b* ((cstss (imf-cst-obs-phrase-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-phrase-list-conc-match (implies (imf-cst-matchp cst "obs-phrase-list") (b* ((cstss (imf-cst-obs-phrase-list-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ phrase / cfws ] *( \",\" [ phrase / cfws ] )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-phrase-list-conc-of-tree-fix-cst (equal (imf-cst-obs-phrase-list-conc (tree-fix cst)) (imf-cst-obs-phrase-list-conc cst)))
Theorem:
(defthm imf-cst-obs-phrase-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-phrase-list-conc cst) (imf-cst-obs-phrase-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-fws-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-fws"))) (let ((__function__ 'imf-cst-obs-fws-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-fws-conc (b* ((cstss (imf-cst-obs-fws-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-fws-conc-match (implies (imf-cst-matchp cst "obs-fws") (b* ((cstss (imf-cst-obs-fws-conc cst))) (imf-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-fws-conc-of-tree-fix-cst (equal (imf-cst-obs-fws-conc (tree-fix cst)) (imf-cst-obs-fws-conc cst)))
Theorem:
(defthm imf-cst-obs-fws-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-fws-conc cst) (imf-cst-obs-fws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-day-of-week-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-day-of-week"))) (let ((__function__ 'imf-cst-obs-day-of-week-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-day-of-week-conc (b* ((cstss (imf-cst-obs-day-of-week-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-day-of-week-conc-match (implies (imf-cst-matchp cst "obs-day-of-week") (b* ((cstss (imf-cst-obs-day-of-week-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] day-name [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-day-of-week-conc-of-tree-fix-cst (equal (imf-cst-obs-day-of-week-conc (tree-fix cst)) (imf-cst-obs-day-of-week-conc cst)))
Theorem:
(defthm imf-cst-obs-day-of-week-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-day-of-week-conc cst) (imf-cst-obs-day-of-week-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-day-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-day"))) (let ((__function__ 'imf-cst-obs-day-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-day-conc (b* ((cstss (imf-cst-obs-day-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-day-conc-match (implies (imf-cst-matchp cst "obs-day") (b* ((cstss (imf-cst-obs-day-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 1*2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-day-conc-of-tree-fix-cst (equal (imf-cst-obs-day-conc (tree-fix cst)) (imf-cst-obs-day-conc cst)))
Theorem:
(defthm imf-cst-obs-day-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-day-conc cst) (imf-cst-obs-day-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-year-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-year"))) (let ((__function__ 'imf-cst-obs-year-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-year-conc (b* ((cstss (imf-cst-obs-year-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-year-conc-match (implies (imf-cst-matchp cst "obs-year") (b* ((cstss (imf-cst-obs-year-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2*digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-year-conc-of-tree-fix-cst (equal (imf-cst-obs-year-conc (tree-fix cst)) (imf-cst-obs-year-conc cst)))
Theorem:
(defthm imf-cst-obs-year-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-year-conc cst) (imf-cst-obs-year-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-hour-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-hour"))) (let ((__function__ 'imf-cst-obs-hour-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-hour-conc (b* ((cstss (imf-cst-obs-hour-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-hour-conc-match (implies (imf-cst-matchp cst "obs-hour") (b* ((cstss (imf-cst-obs-hour-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-hour-conc-of-tree-fix-cst (equal (imf-cst-obs-hour-conc (tree-fix cst)) (imf-cst-obs-hour-conc cst)))
Theorem:
(defthm imf-cst-obs-hour-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-hour-conc cst) (imf-cst-obs-hour-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-minute-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-minute"))) (let ((__function__ 'imf-cst-obs-minute-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-minute-conc (b* ((cstss (imf-cst-obs-minute-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-minute-conc-match (implies (imf-cst-matchp cst "obs-minute") (b* ((cstss (imf-cst-obs-minute-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-minute-conc-of-tree-fix-cst (equal (imf-cst-obs-minute-conc (tree-fix cst)) (imf-cst-obs-minute-conc cst)))
Theorem:
(defthm imf-cst-obs-minute-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-minute-conc cst) (imf-cst-obs-minute-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-second-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-second"))) (let ((__function__ 'imf-cst-obs-second-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-second-conc (b* ((cstss (imf-cst-obs-second-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-second-conc-match (implies (imf-cst-matchp cst "obs-second") (b* ((cstss (imf-cst-obs-second-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] 2digit [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-second-conc-of-tree-fix-cst (equal (imf-cst-obs-second-conc (tree-fix cst)) (imf-cst-obs-second-conc cst)))
Theorem:
(defthm imf-cst-obs-second-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-second-conc cst) (imf-cst-obs-second-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-angle-addr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-angle-addr"))) (let ((__function__ 'imf-cst-obs-angle-addr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-angle-addr-conc (b* ((cstss (imf-cst-obs-angle-addr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-angle-addr-conc-match (implies (imf-cst-matchp cst "obs-angle-addr") (b* ((cstss (imf-cst-obs-angle-addr-conc cst))) (imf-cst-list-list-conc-matchp cstss "[ cfws ] \"<\" obs-route addr-spec \">\" [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-angle-addr-conc-of-tree-fix-cst (equal (imf-cst-obs-angle-addr-conc (tree-fix cst)) (imf-cst-obs-angle-addr-conc cst)))
Theorem:
(defthm imf-cst-obs-angle-addr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-angle-addr-conc cst) (imf-cst-obs-angle-addr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-route-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-route"))) (let ((__function__ 'imf-cst-obs-route-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-route-conc (b* ((cstss (imf-cst-obs-route-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-route-conc-match (implies (imf-cst-matchp cst "obs-route") (b* ((cstss (imf-cst-obs-route-conc cst))) (imf-cst-list-list-conc-matchp cstss "obs-domain-list \":\""))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-route-conc-of-tree-fix-cst (equal (imf-cst-obs-route-conc (tree-fix cst)) (imf-cst-obs-route-conc cst)))
Theorem:
(defthm imf-cst-obs-route-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-route-conc cst) (imf-cst-obs-route-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-domain-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-domain-list"))) (let ((__function__ 'imf-cst-obs-domain-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-domain-list-conc (b* ((cstss (imf-cst-obs-domain-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-domain-list-conc-match (implies (imf-cst-matchp cst "obs-domain-list") (b* ((cstss (imf-cst-obs-domain-list-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( cfws / \",\" ) \"@\" domain *( \",\" [ cfws ] [ \"@\" domain ] )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-domain-list-conc-of-tree-fix-cst (equal (imf-cst-obs-domain-list-conc (tree-fix cst)) (imf-cst-obs-domain-list-conc cst)))
Theorem:
(defthm imf-cst-obs-domain-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-domain-list-conc cst) (imf-cst-obs-domain-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-mbox-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-mbox-list"))) (let ((__function__ 'imf-cst-obs-mbox-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-mbox-list-conc (b* ((cstss (imf-cst-obs-mbox-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-mbox-list-conc-match (implies (imf-cst-matchp cst "obs-mbox-list") (b* ((cstss (imf-cst-obs-mbox-list-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( [ cfws ] \",\" ) mailbox *( \",\" [ mailbox / cfws ] )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-mbox-list-conc-of-tree-fix-cst (equal (imf-cst-obs-mbox-list-conc (tree-fix cst)) (imf-cst-obs-mbox-list-conc cst)))
Theorem:
(defthm imf-cst-obs-mbox-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-mbox-list-conc cst) (imf-cst-obs-mbox-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-addr-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-addr-list"))) (let ((__function__ 'imf-cst-obs-addr-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-addr-list-conc (b* ((cstss (imf-cst-obs-addr-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-addr-list-conc-match (implies (imf-cst-matchp cst "obs-addr-list") (b* ((cstss (imf-cst-obs-addr-list-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( [ cfws ] \",\" ) address *( \",\" [ address / cfws ] )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-addr-list-conc-of-tree-fix-cst (equal (imf-cst-obs-addr-list-conc (tree-fix cst)) (imf-cst-obs-addr-list-conc cst)))
Theorem:
(defthm imf-cst-obs-addr-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-addr-list-conc cst) (imf-cst-obs-addr-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-group-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-group-list"))) (let ((__function__ 'imf-cst-obs-group-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-group-list-conc (b* ((cstss (imf-cst-obs-group-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-group-list-conc-match (implies (imf-cst-matchp cst "obs-group-list") (b* ((cstss (imf-cst-obs-group-list-conc cst))) (imf-cst-list-list-conc-matchp cstss "1*( [ cfws ] \",\" ) [ cfws ]"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-group-list-conc-of-tree-fix-cst (equal (imf-cst-obs-group-list-conc (tree-fix cst)) (imf-cst-obs-group-list-conc cst)))
Theorem:
(defthm imf-cst-obs-group-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-group-list-conc cst) (imf-cst-obs-group-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-local-part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-local-part"))) (let ((__function__ 'imf-cst-obs-local-part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-local-part-conc (b* ((cstss (imf-cst-obs-local-part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-local-part-conc-match (implies (imf-cst-matchp cst "obs-local-part") (b* ((cstss (imf-cst-obs-local-part-conc cst))) (imf-cst-list-list-conc-matchp cstss "word *( \".\" word )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-local-part-conc-of-tree-fix-cst (equal (imf-cst-obs-local-part-conc (tree-fix cst)) (imf-cst-obs-local-part-conc cst)))
Theorem:
(defthm imf-cst-obs-local-part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-local-part-conc cst) (imf-cst-obs-local-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-domain-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-domain"))) (let ((__function__ 'imf-cst-obs-domain-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-domain-conc (b* ((cstss (imf-cst-obs-domain-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-domain-conc-match (implies (imf-cst-matchp cst "obs-domain") (b* ((cstss (imf-cst-obs-domain-conc cst))) (imf-cst-list-list-conc-matchp cstss "atom *( \".\" atom )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-domain-conc-of-tree-fix-cst (equal (imf-cst-obs-domain-conc (tree-fix cst)) (imf-cst-obs-domain-conc cst)))
Theorem:
(defthm imf-cst-obs-domain-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-domain-conc cst) (imf-cst-obs-domain-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'imf-cst-obs-dtext-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-dtext-conc1 (b* ((cstss (imf-cst-obs-dtext-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)) (b* ((cstss (imf-cst-obs-dtext-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc1 (tree-fix cst)) (imf-cst-obs-dtext-conc1 cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc1 cst) (imf-cst-obs-dtext-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'imf-cst-obs-dtext-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-dtext-conc2 (b* ((cstss (imf-cst-obs-dtext-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)) (b* ((cstss (imf-cst-obs-dtext-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc2 (tree-fix cst)) (imf-cst-obs-dtext-conc2 cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc2 cst) (imf-cst-obs-dtext-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-fields-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-fields"))) (let ((__function__ 'imf-cst-obs-fields-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-fields-conc (b* ((cstss (imf-cst-obs-fields-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-fields-conc-match (implies (imf-cst-matchp cst "obs-fields") (b* ((cstss (imf-cst-obs-fields-conc cst))) (imf-cst-list-list-conc-matchp cstss "*( obs-return / obs-received / obs-orig-date / obs-from / obs-sender / obs-reply-to / obs-to / obs-cc / obs-bcc / obs-message-id / obs-in-reply-to / obs-references / obs-subject / obs-comments / obs-keywords / obs-resent-date / obs-resent-from / obs-resent-send / obs-resent-rply / obs-resent-to / obs-resent-cc / obs-resent-bcc / obs-resent-mid / obs-optional )"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-fields-conc-of-tree-fix-cst (equal (imf-cst-obs-fields-conc (tree-fix cst)) (imf-cst-obs-fields-conc cst)))
Theorem:
(defthm imf-cst-obs-fields-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-fields-conc cst) (imf-cst-obs-fields-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-orig-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-orig-date"))) (let ((__function__ 'imf-cst-obs-orig-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-orig-date-conc (b* ((cstss (imf-cst-obs-orig-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-orig-date-conc-match (implies (imf-cst-matchp cst "obs-orig-date") (b* ((cstss (imf-cst-obs-orig-date-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Date\" *wsp \":\" date-time crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-orig-date-conc-of-tree-fix-cst (equal (imf-cst-obs-orig-date-conc (tree-fix cst)) (imf-cst-obs-orig-date-conc cst)))
Theorem:
(defthm imf-cst-obs-orig-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-orig-date-conc cst) (imf-cst-obs-orig-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-from-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-from"))) (let ((__function__ 'imf-cst-obs-from-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-from-conc (b* ((cstss (imf-cst-obs-from-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-from-conc-match (implies (imf-cst-matchp cst "obs-from") (b* ((cstss (imf-cst-obs-from-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"From\" *wsp \":\" mailbox-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-from-conc-of-tree-fix-cst (equal (imf-cst-obs-from-conc (tree-fix cst)) (imf-cst-obs-from-conc cst)))
Theorem:
(defthm imf-cst-obs-from-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-from-conc cst) (imf-cst-obs-from-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-sender-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-sender"))) (let ((__function__ 'imf-cst-obs-sender-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-sender-conc (b* ((cstss (imf-cst-obs-sender-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-sender-conc-match (implies (imf-cst-matchp cst "obs-sender") (b* ((cstss (imf-cst-obs-sender-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Sender\" *wsp \":\" mailbox crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-sender-conc-of-tree-fix-cst (equal (imf-cst-obs-sender-conc (tree-fix cst)) (imf-cst-obs-sender-conc cst)))
Theorem:
(defthm imf-cst-obs-sender-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-sender-conc cst) (imf-cst-obs-sender-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-reply-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-reply-to"))) (let ((__function__ 'imf-cst-obs-reply-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-reply-to-conc (b* ((cstss (imf-cst-obs-reply-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-reply-to-conc-match (implies (imf-cst-matchp cst "obs-reply-to") (b* ((cstss (imf-cst-obs-reply-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Reply-To\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-reply-to-conc-of-tree-fix-cst (equal (imf-cst-obs-reply-to-conc (tree-fix cst)) (imf-cst-obs-reply-to-conc cst)))
Theorem:
(defthm imf-cst-obs-reply-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-reply-to-conc cst) (imf-cst-obs-reply-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-to"))) (let ((__function__ 'imf-cst-obs-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-to-conc (b* ((cstss (imf-cst-obs-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-to-conc-match (implies (imf-cst-matchp cst "obs-to") (b* ((cstss (imf-cst-obs-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"To\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-to-conc-of-tree-fix-cst (equal (imf-cst-obs-to-conc (tree-fix cst)) (imf-cst-obs-to-conc cst)))
Theorem:
(defthm imf-cst-obs-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-to-conc cst) (imf-cst-obs-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-cc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-cc"))) (let ((__function__ 'imf-cst-obs-cc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-cc-conc (b* ((cstss (imf-cst-obs-cc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-cc-conc-match (implies (imf-cst-matchp cst "obs-cc") (b* ((cstss (imf-cst-obs-cc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Cc\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-cc-conc-of-tree-fix-cst (equal (imf-cst-obs-cc-conc (tree-fix cst)) (imf-cst-obs-cc-conc cst)))
Theorem:
(defthm imf-cst-obs-cc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-cc-conc cst) (imf-cst-obs-cc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-bcc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-bcc"))) (let ((__function__ 'imf-cst-obs-bcc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-bcc-conc (b* ((cstss (imf-cst-obs-bcc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-bcc-conc-match (implies (imf-cst-matchp cst "obs-bcc") (b* ((cstss (imf-cst-obs-bcc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-bcc-conc-of-tree-fix-cst (equal (imf-cst-obs-bcc-conc (tree-fix cst)) (imf-cst-obs-bcc-conc cst)))
Theorem:
(defthm imf-cst-obs-bcc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-bcc-conc cst) (imf-cst-obs-bcc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-message-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-message-id"))) (let ((__function__ 'imf-cst-obs-message-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-message-id-conc (b* ((cstss (imf-cst-obs-message-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-message-id-conc-match (implies (imf-cst-matchp cst "obs-message-id") (b* ((cstss (imf-cst-obs-message-id-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Message-ID\" *wsp \":\" msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-message-id-conc-of-tree-fix-cst (equal (imf-cst-obs-message-id-conc (tree-fix cst)) (imf-cst-obs-message-id-conc cst)))
Theorem:
(defthm imf-cst-obs-message-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-message-id-conc cst) (imf-cst-obs-message-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-in-reply-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-in-reply-to"))) (let ((__function__ 'imf-cst-obs-in-reply-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-in-reply-to-conc (b* ((cstss (imf-cst-obs-in-reply-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-in-reply-to-conc-match (implies (imf-cst-matchp cst "obs-in-reply-to") (b* ((cstss (imf-cst-obs-in-reply-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"In-Reply-To\" *wsp \":\" *( phrase / msg-id ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-in-reply-to-conc-of-tree-fix-cst (equal (imf-cst-obs-in-reply-to-conc (tree-fix cst)) (imf-cst-obs-in-reply-to-conc cst)))
Theorem:
(defthm imf-cst-obs-in-reply-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-in-reply-to-conc cst) (imf-cst-obs-in-reply-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-references-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-references"))) (let ((__function__ 'imf-cst-obs-references-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-references-conc (b* ((cstss (imf-cst-obs-references-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-references-conc-match (implies (imf-cst-matchp cst "obs-references") (b* ((cstss (imf-cst-obs-references-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"References\" *wsp \":\" *( phrase / msg-id ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-references-conc-of-tree-fix-cst (equal (imf-cst-obs-references-conc (tree-fix cst)) (imf-cst-obs-references-conc cst)))
Theorem:
(defthm imf-cst-obs-references-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-references-conc cst) (imf-cst-obs-references-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-left-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-left"))) (let ((__function__ 'imf-cst-obs-id-left-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-id-left-conc (b* ((cstss (imf-cst-obs-id-left-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-match (implies (imf-cst-matchp cst "obs-id-left") (b* ((cstss (imf-cst-obs-id-left-conc cst))) (imf-cst-list-list-conc-matchp cstss "local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-of-tree-fix-cst (equal (imf-cst-obs-id-left-conc (tree-fix cst)) (imf-cst-obs-id-left-conc cst)))
Theorem:
(defthm imf-cst-obs-id-left-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-left-conc cst) (imf-cst-obs-id-left-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-right-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-right"))) (let ((__function__ 'imf-cst-obs-id-right-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-id-right-conc (b* ((cstss (imf-cst-obs-id-right-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-match (implies (imf-cst-matchp cst "obs-id-right") (b* ((cstss (imf-cst-obs-id-right-conc cst))) (imf-cst-list-list-conc-matchp cstss "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-of-tree-fix-cst (equal (imf-cst-obs-id-right-conc (tree-fix cst)) (imf-cst-obs-id-right-conc cst)))
Theorem:
(defthm imf-cst-obs-id-right-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-right-conc cst) (imf-cst-obs-id-right-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-subject-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-subject"))) (let ((__function__ 'imf-cst-obs-subject-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-subject-conc (b* ((cstss (imf-cst-obs-subject-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-subject-conc-match (implies (imf-cst-matchp cst "obs-subject") (b* ((cstss (imf-cst-obs-subject-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Subject\" *wsp \":\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-subject-conc-of-tree-fix-cst (equal (imf-cst-obs-subject-conc (tree-fix cst)) (imf-cst-obs-subject-conc cst)))
Theorem:
(defthm imf-cst-obs-subject-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-subject-conc cst) (imf-cst-obs-subject-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-comments-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-comments"))) (let ((__function__ 'imf-cst-obs-comments-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-comments-conc (b* ((cstss (imf-cst-obs-comments-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-comments-conc-match (implies (imf-cst-matchp cst "obs-comments") (b* ((cstss (imf-cst-obs-comments-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Comments\" *wsp \":\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-comments-conc-of-tree-fix-cst (equal (imf-cst-obs-comments-conc (tree-fix cst)) (imf-cst-obs-comments-conc cst)))
Theorem:
(defthm imf-cst-obs-comments-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-comments-conc cst) (imf-cst-obs-comments-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-keywords-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-keywords"))) (let ((__function__ 'imf-cst-obs-keywords-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-keywords-conc (b* ((cstss (imf-cst-obs-keywords-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-keywords-conc-match (implies (imf-cst-matchp cst "obs-keywords") (b* ((cstss (imf-cst-obs-keywords-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Keywords\" *wsp \":\" obs-phrase-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-keywords-conc-of-tree-fix-cst (equal (imf-cst-obs-keywords-conc (tree-fix cst)) (imf-cst-obs-keywords-conc cst)))
Theorem:
(defthm imf-cst-obs-keywords-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-keywords-conc cst) (imf-cst-obs-keywords-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-from-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-from"))) (let ((__function__ 'imf-cst-obs-resent-from-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-from-conc (b* ((cstss (imf-cst-obs-resent-from-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-from-conc-match (implies (imf-cst-matchp cst "obs-resent-from") (b* ((cstss (imf-cst-obs-resent-from-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-From\" *wsp \":\" mailbox-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-from-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-from-conc (tree-fix cst)) (imf-cst-obs-resent-from-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-from-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-from-conc cst) (imf-cst-obs-resent-from-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-send-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-send"))) (let ((__function__ 'imf-cst-obs-resent-send-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-send-conc (b* ((cstss (imf-cst-obs-resent-send-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-send-conc-match (implies (imf-cst-matchp cst "obs-resent-send") (b* ((cstss (imf-cst-obs-resent-send-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Sender\" *wsp \":\" mailbox crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-send-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-send-conc (tree-fix cst)) (imf-cst-obs-resent-send-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-send-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-send-conc cst) (imf-cst-obs-resent-send-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-date"))) (let ((__function__ 'imf-cst-obs-resent-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-date-conc (b* ((cstss (imf-cst-obs-resent-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-date-conc-match (implies (imf-cst-matchp cst "obs-resent-date") (b* ((cstss (imf-cst-obs-resent-date-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Date\" *wsp \":\" date-time crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-date-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-date-conc (tree-fix cst)) (imf-cst-obs-resent-date-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-date-conc cst) (imf-cst-obs-resent-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-to"))) (let ((__function__ 'imf-cst-obs-resent-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-to-conc (b* ((cstss (imf-cst-obs-resent-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-to-conc-match (implies (imf-cst-matchp cst "obs-resent-to") (b* ((cstss (imf-cst-obs-resent-to-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-To\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-to-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-to-conc (tree-fix cst)) (imf-cst-obs-resent-to-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-to-conc cst) (imf-cst-obs-resent-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-cc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-cc"))) (let ((__function__ 'imf-cst-obs-resent-cc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-cc-conc (b* ((cstss (imf-cst-obs-resent-cc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-cc-conc-match (implies (imf-cst-matchp cst "obs-resent-cc") (b* ((cstss (imf-cst-obs-resent-cc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Cc\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-cc-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-cc-conc (tree-fix cst)) (imf-cst-obs-resent-cc-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-cc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-cc-conc cst) (imf-cst-obs-resent-cc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-bcc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-bcc"))) (let ((__function__ 'imf-cst-obs-resent-bcc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-bcc-conc (b* ((cstss (imf-cst-obs-resent-bcc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-bcc-conc-match (implies (imf-cst-matchp cst "obs-resent-bcc") (b* ((cstss (imf-cst-obs-resent-bcc-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Bcc\" *wsp \":\" ( address-list / ( *( [ cfws ] \",\" ) [ cfws ] ) ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-bcc-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-bcc-conc (tree-fix cst)) (imf-cst-obs-resent-bcc-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-bcc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-bcc-conc cst) (imf-cst-obs-resent-bcc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-mid-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-mid"))) (let ((__function__ 'imf-cst-obs-resent-mid-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-mid-conc (b* ((cstss (imf-cst-obs-resent-mid-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-mid-conc-match (implies (imf-cst-matchp cst "obs-resent-mid") (b* ((cstss (imf-cst-obs-resent-mid-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Message-ID\" *wsp \":\" msg-id crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-mid-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-mid-conc (tree-fix cst)) (imf-cst-obs-resent-mid-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-mid-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-mid-conc cst) (imf-cst-obs-resent-mid-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-resent-rply-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-resent-rply"))) (let ((__function__ 'imf-cst-obs-resent-rply-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-resent-rply-conc (b* ((cstss (imf-cst-obs-resent-rply-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-rply-conc-match (implies (imf-cst-matchp cst "obs-resent-rply") (b* ((cstss (imf-cst-obs-resent-rply-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Resent-Reply-To\" *wsp \":\" address-list crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-resent-rply-conc-of-tree-fix-cst (equal (imf-cst-obs-resent-rply-conc (tree-fix cst)) (imf-cst-obs-resent-rply-conc cst)))
Theorem:
(defthm imf-cst-obs-resent-rply-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-resent-rply-conc cst) (imf-cst-obs-resent-rply-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-return-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-return"))) (let ((__function__ 'imf-cst-obs-return-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-return-conc (b* ((cstss (imf-cst-obs-return-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-return-conc-match (implies (imf-cst-matchp cst "obs-return") (b* ((cstss (imf-cst-obs-return-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Return-Path\" *wsp \":\" path crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-return-conc-of-tree-fix-cst (equal (imf-cst-obs-return-conc (tree-fix cst)) (imf-cst-obs-return-conc cst)))
Theorem:
(defthm imf-cst-obs-return-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-return-conc cst) (imf-cst-obs-return-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-received-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-received"))) (let ((__function__ 'imf-cst-obs-received-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-received-conc (b* ((cstss (imf-cst-obs-received-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-received-conc-match (implies (imf-cst-matchp cst "obs-received") (b* ((cstss (imf-cst-obs-received-conc cst))) (imf-cst-list-list-conc-matchp cstss "\"Received\" *wsp \":\" *received-token crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-received-conc-of-tree-fix-cst (equal (imf-cst-obs-received-conc (tree-fix cst)) (imf-cst-obs-received-conc cst)))
Theorem:
(defthm imf-cst-obs-received-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-received-conc cst) (imf-cst-obs-received-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-optional-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-optional"))) (let ((__function__ 'imf-cst-obs-optional-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-obs-optional-conc (b* ((cstss (imf-cst-obs-optional-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-optional-conc-match (implies (imf-cst-matchp cst "obs-optional") (b* ((cstss (imf-cst-obs-optional-conc cst))) (imf-cst-list-list-conc-matchp cstss "field-name *wsp \":\" unstructured crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-optional-conc-of-tree-fix-cst (equal (imf-cst-obs-optional-conc (tree-fix cst)) (imf-cst-obs-optional-conc cst)))
Theorem:
(defthm imf-cst-obs-optional-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-optional-conc cst) (imf-cst-obs-optional-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-cr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "cr"))) (let ((__function__ 'imf-cst-cr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-cr-conc (b* ((cstss (imf-cst-cr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-match (implies (imf-cst-matchp cst "cr") (b* ((cstss (imf-cst-cr-conc cst))) (imf-cst-list-list-conc-matchp cstss "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-of-tree-fix-cst (equal (imf-cst-cr-conc (tree-fix cst)) (imf-cst-cr-conc cst)))
Theorem:
(defthm imf-cst-cr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-cr-conc cst) (imf-cst-cr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-crlf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "crlf"))) (let ((__function__ 'imf-cst-crlf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-crlf-conc (b* ((cstss (imf-cst-crlf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-crlf-conc-match (implies (imf-cst-matchp cst "crlf") (b* ((cstss (imf-cst-crlf-conc cst))) (imf-cst-list-list-conc-matchp cstss "cr lf"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-crlf-conc-of-tree-fix-cst (equal (imf-cst-crlf-conc (tree-fix cst)) (imf-cst-crlf-conc cst)))
Theorem:
(defthm imf-cst-crlf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-crlf-conc cst) (imf-cst-crlf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-digit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "digit"))) (let ((__function__ 'imf-cst-digit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-digit-conc (b* ((cstss (imf-cst-digit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-match (implies (imf-cst-matchp cst "digit") (b* ((cstss (imf-cst-digit-conc cst))) (imf-cst-list-list-conc-matchp cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-of-tree-fix-cst (equal (imf-cst-digit-conc (tree-fix cst)) (imf-cst-digit-conc cst)))
Theorem:
(defthm imf-cst-digit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-digit-conc cst) (imf-cst-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-dquote-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "dquote"))) (let ((__function__ 'imf-cst-dquote-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-dquote-conc (b* ((cstss (imf-cst-dquote-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-match (implies (imf-cst-matchp cst "dquote") (b* ((cstss (imf-cst-dquote-conc cst))) (imf-cst-list-list-conc-matchp cstss "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-of-tree-fix-cst (equal (imf-cst-dquote-conc (tree-fix cst)) (imf-cst-dquote-conc cst)))
Theorem:
(defthm imf-cst-dquote-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-dquote-conc cst) (imf-cst-dquote-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-lf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "lf"))) (let ((__function__ 'imf-cst-lf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-lf-conc (b* ((cstss (imf-cst-lf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-match (implies (imf-cst-matchp cst "lf") (b* ((cstss (imf-cst-lf-conc cst))) (imf-cst-list-list-conc-matchp cstss "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-of-tree-fix-cst (equal (imf-cst-lf-conc (tree-fix cst)) (imf-cst-lf-conc cst)))
Theorem:
(defthm imf-cst-lf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-lf-conc cst) (imf-cst-lf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-vchar-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "vchar"))) (let ((__function__ 'imf-cst-vchar-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-vchar-conc (b* ((cstss (imf-cst-vchar-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-match (implies (imf-cst-matchp cst "vchar") (b* ((cstss (imf-cst-vchar-conc cst))) (imf-cst-list-list-conc-matchp cstss "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-of-tree-fix-cst (equal (imf-cst-vchar-conc (tree-fix cst)) (imf-cst-vchar-conc cst)))
Theorem:
(defthm imf-cst-vchar-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-vchar-conc cst) (imf-cst-vchar-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)))) (let ((__function__ 'imf-cst-wsp-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-wsp-conc1 (b* ((cstss (imf-cst-wsp-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)) (b* ((cstss (imf-cst-wsp-conc1 cst))) (imf-cst-list-list-conc-matchp cstss "sp"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-of-tree-fix-cst (equal (imf-cst-wsp-conc1 (tree-fix cst)) (imf-cst-wsp-conc1 cst)))
Theorem:
(defthm imf-cst-wsp-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc1 cst) (imf-cst-wsp-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)))) (let ((__function__ 'imf-cst-wsp-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-wsp-conc2 (b* ((cstss (imf-cst-wsp-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)) (b* ((cstss (imf-cst-wsp-conc2 cst))) (imf-cst-list-list-conc-matchp cstss "htab"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-of-tree-fix-cst (equal (imf-cst-wsp-conc2 (tree-fix cst)) (imf-cst-wsp-conc2 cst)))
Theorem:
(defthm imf-cst-wsp-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc2 cst) (imf-cst-wsp-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-htab-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "htab"))) (let ((__function__ 'imf-cst-htab-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-htab-conc (b* ((cstss (imf-cst-htab-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-match (implies (imf-cst-matchp cst "htab") (b* ((cstss (imf-cst-htab-conc cst))) (imf-cst-list-list-conc-matchp cstss "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-of-tree-fix-cst (equal (imf-cst-htab-conc (tree-fix cst)) (imf-cst-htab-conc cst)))
Theorem:
(defthm imf-cst-htab-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-htab-conc cst) (imf-cst-htab-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-sp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "sp"))) (let ((__function__ 'imf-cst-sp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imf-cst-sp-conc (b* ((cstss (imf-cst-sp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-match (implies (imf-cst-matchp cst "sp") (b* ((cstss (imf-cst-sp-conc cst))) (imf-cst-list-list-conc-matchp cstss "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-of-tree-fix-cst (equal (imf-cst-sp-conc (tree-fix cst)) (imf-cst-sp-conc cst)))
Theorem:
(defthm imf-cst-sp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-sp-conc cst) (imf-cst-sp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-ccontent-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-ccontent-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-ccontent-conc1-rep (b* ((csts (imf-cst-ccontent-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-rep-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)) (b* ((csts (imf-cst-ccontent-conc1-rep cst))) (imf-cst-list-rep-matchp csts "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-rep-of-tree-fix-cst (equal (imf-cst-ccontent-conc1-rep (tree-fix cst)) (imf-cst-ccontent-conc1-rep cst)))
Theorem:
(defthm imf-cst-ccontent-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc1-rep cst) (imf-cst-ccontent-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-ccontent-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-ccontent-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-ccontent-conc2-rep (b* ((csts (imf-cst-ccontent-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-rep-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)) (b* ((csts (imf-cst-ccontent-conc2-rep cst))) (imf-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-rep-of-tree-fix-cst (equal (imf-cst-ccontent-conc2-rep (tree-fix cst)) (imf-cst-ccontent-conc2-rep cst)))
Theorem:
(defthm imf-cst-ccontent-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc2-rep cst) (imf-cst-ccontent-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'imf-cst-ccontent-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-ccontent-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-ccontent-conc3-rep (b* ((csts (imf-cst-ccontent-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-rep-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)) (b* ((csts (imf-cst-ccontent-conc3-rep cst))) (imf-cst-list-rep-matchp csts "comment"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-rep-of-tree-fix-cst (equal (imf-cst-ccontent-conc3-rep (tree-fix cst)) (imf-cst-ccontent-conc3-rep cst)))
Theorem:
(defthm imf-cst-ccontent-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc3-rep cst) (imf-cst-ccontent-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-qcontent-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-qcontent-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-qcontent-conc1-rep (b* ((csts (imf-cst-qcontent-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-rep-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)) (b* ((csts (imf-cst-qcontent-conc1-rep cst))) (imf-cst-list-rep-matchp csts "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-rep-of-tree-fix-cst (equal (imf-cst-qcontent-conc1-rep (tree-fix cst)) (imf-cst-qcontent-conc1-rep cst)))
Theorem:
(defthm imf-cst-qcontent-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc1-rep cst) (imf-cst-qcontent-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-qcontent-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-qcontent-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-qcontent-conc2-rep (b* ((csts (imf-cst-qcontent-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-rep-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)) (b* ((csts (imf-cst-qcontent-conc2-rep cst))) (imf-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-rep-of-tree-fix-cst (equal (imf-cst-qcontent-conc2-rep (tree-fix cst)) (imf-cst-qcontent-conc2-rep cst)))
Theorem:
(defthm imf-cst-qcontent-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc2-rep cst) (imf-cst-qcontent-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)))) (let ((__function__ 'imf-cst-word-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-word-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-word-conc1-rep (b* ((csts (imf-cst-word-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-rep-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)) (b* ((csts (imf-cst-word-conc1-rep cst))) (imf-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-rep-of-tree-fix-cst (equal (imf-cst-word-conc1-rep (tree-fix cst)) (imf-cst-word-conc1-rep cst)))
Theorem:
(defthm imf-cst-word-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc1-rep cst) (imf-cst-word-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)))) (let ((__function__ 'imf-cst-word-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-word-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-word-conc2-rep (b* ((csts (imf-cst-word-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-rep-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)) (b* ((csts (imf-cst-word-conc2-rep cst))) (imf-cst-list-rep-matchp csts "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-rep-of-tree-fix-cst (equal (imf-cst-word-conc2-rep (tree-fix cst)) (imf-cst-word-conc2-rep cst)))
Theorem:
(defthm imf-cst-word-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc2-rep cst) (imf-cst-word-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)))) (let ((__function__ 'imf-cst-address-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-address-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-address-conc1-rep (b* ((csts (imf-cst-address-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-rep-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)) (b* ((csts (imf-cst-address-conc1-rep cst))) (imf-cst-list-rep-matchp csts "mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-rep-of-tree-fix-cst (equal (imf-cst-address-conc1-rep (tree-fix cst)) (imf-cst-address-conc1-rep cst)))
Theorem:
(defthm imf-cst-address-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc1-rep cst) (imf-cst-address-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)))) (let ((__function__ 'imf-cst-address-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-address-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-address-conc2-rep (b* ((csts (imf-cst-address-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-rep-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)) (b* ((csts (imf-cst-address-conc2-rep cst))) (imf-cst-list-rep-matchp csts "group"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-rep-of-tree-fix-cst (equal (imf-cst-address-conc2-rep (tree-fix cst)) (imf-cst-address-conc2-rep cst)))
Theorem:
(defthm imf-cst-address-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc2-rep cst) (imf-cst-address-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)))) (let ((__function__ 'imf-cst-mailbox-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-mailbox-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-mailbox-conc1-rep (b* ((csts (imf-cst-mailbox-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-rep-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)) (b* ((csts (imf-cst-mailbox-conc1-rep cst))) (imf-cst-list-rep-matchp csts "name-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-rep-of-tree-fix-cst (equal (imf-cst-mailbox-conc1-rep (tree-fix cst)) (imf-cst-mailbox-conc1-rep cst)))
Theorem:
(defthm imf-cst-mailbox-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc1-rep cst) (imf-cst-mailbox-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)))) (let ((__function__ 'imf-cst-mailbox-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-mailbox-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-mailbox-conc2-rep (b* ((csts (imf-cst-mailbox-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-rep-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)) (b* ((csts (imf-cst-mailbox-conc2-rep cst))) (imf-cst-list-rep-matchp csts "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-rep-of-tree-fix-cst (equal (imf-cst-mailbox-conc2-rep (tree-fix cst)) (imf-cst-mailbox-conc2-rep cst)))
Theorem:
(defthm imf-cst-mailbox-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc2-rep cst) (imf-cst-mailbox-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-display-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "display-name"))) (let ((__function__ 'imf-cst-display-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-display-name-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-display-name-conc-rep (b* ((csts (imf-cst-display-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-rep-match (implies (imf-cst-matchp cst "display-name") (b* ((csts (imf-cst-display-name-conc-rep cst))) (imf-cst-list-rep-matchp csts "phrase"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-rep-of-tree-fix-cst (equal (imf-cst-display-name-conc-rep (tree-fix cst)) (imf-cst-display-name-conc-rep cst)))
Theorem:
(defthm imf-cst-display-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-display-name-conc-rep cst) (imf-cst-display-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)))) (let ((__function__ 'imf-cst-group-list-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-group-list-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-group-list-conc1-rep (b* ((csts (imf-cst-group-list-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-rep-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)) (b* ((csts (imf-cst-group-list-conc1-rep cst))) (imf-cst-list-rep-matchp csts "mailbox-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-rep-of-tree-fix-cst (equal (imf-cst-group-list-conc1-rep (tree-fix cst)) (imf-cst-group-list-conc1-rep cst)))
Theorem:
(defthm imf-cst-group-list-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc1-rep cst) (imf-cst-group-list-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)))) (let ((__function__ 'imf-cst-group-list-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-group-list-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-group-list-conc2-rep (b* ((csts (imf-cst-group-list-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-rep-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)) (b* ((csts (imf-cst-group-list-conc2-rep cst))) (imf-cst-list-rep-matchp csts "cfws"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-rep-of-tree-fix-cst (equal (imf-cst-group-list-conc2-rep (tree-fix cst)) (imf-cst-group-list-conc2-rep cst)))
Theorem:
(defthm imf-cst-group-list-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc2-rep cst) (imf-cst-group-list-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)))) (let ((__function__ 'imf-cst-group-list-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-group-list-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-group-list-conc3-rep (b* ((csts (imf-cst-group-list-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-rep-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)) (b* ((csts (imf-cst-group-list-conc3-rep cst))) (imf-cst-list-rep-matchp csts "obs-group-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-rep-of-tree-fix-cst (equal (imf-cst-group-list-conc3-rep (tree-fix cst)) (imf-cst-group-list-conc3-rep cst)))
Theorem:
(defthm imf-cst-group-list-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc3-rep cst) (imf-cst-group-list-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)))) (let ((__function__ 'imf-cst-local-part-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-local-part-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-local-part-conc1-rep (b* ((csts (imf-cst-local-part-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-rep-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)) (b* ((csts (imf-cst-local-part-conc1-rep cst))) (imf-cst-list-rep-matchp csts "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-rep-of-tree-fix-cst (equal (imf-cst-local-part-conc1-rep (tree-fix cst)) (imf-cst-local-part-conc1-rep cst)))
Theorem:
(defthm imf-cst-local-part-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc1-rep cst) (imf-cst-local-part-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)))) (let ((__function__ 'imf-cst-local-part-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-local-part-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-local-part-conc2-rep (b* ((csts (imf-cst-local-part-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-rep-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)) (b* ((csts (imf-cst-local-part-conc2-rep cst))) (imf-cst-list-rep-matchp csts "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-rep-of-tree-fix-cst (equal (imf-cst-local-part-conc2-rep (tree-fix cst)) (imf-cst-local-part-conc2-rep cst)))
Theorem:
(defthm imf-cst-local-part-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc2-rep cst) (imf-cst-local-part-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)))) (let ((__function__ 'imf-cst-local-part-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-local-part-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-local-part-conc3-rep (b* ((csts (imf-cst-local-part-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-rep-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)) (b* ((csts (imf-cst-local-part-conc3-rep cst))) (imf-cst-list-rep-matchp csts "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-rep-of-tree-fix-cst (equal (imf-cst-local-part-conc3-rep (tree-fix cst)) (imf-cst-local-part-conc3-rep cst)))
Theorem:
(defthm imf-cst-local-part-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc3-rep cst) (imf-cst-local-part-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)))) (let ((__function__ 'imf-cst-domain-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-domain-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-domain-conc1-rep (b* ((csts (imf-cst-domain-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-rep-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)) (b* ((csts (imf-cst-domain-conc1-rep cst))) (imf-cst-list-rep-matchp csts "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-rep-of-tree-fix-cst (equal (imf-cst-domain-conc1-rep (tree-fix cst)) (imf-cst-domain-conc1-rep cst)))
Theorem:
(defthm imf-cst-domain-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc1-rep cst) (imf-cst-domain-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)))) (let ((__function__ 'imf-cst-domain-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-domain-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-domain-conc2-rep (b* ((csts (imf-cst-domain-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-rep-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)) (b* ((csts (imf-cst-domain-conc2-rep cst))) (imf-cst-list-rep-matchp csts "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-rep-of-tree-fix-cst (equal (imf-cst-domain-conc2-rep (tree-fix cst)) (imf-cst-domain-conc2-rep cst)))
Theorem:
(defthm imf-cst-domain-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc2-rep cst) (imf-cst-domain-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)))) (let ((__function__ 'imf-cst-domain-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-domain-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-domain-conc3-rep (b* ((csts (imf-cst-domain-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-rep-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)) (b* ((csts (imf-cst-domain-conc3-rep cst))) (imf-cst-list-rep-matchp csts "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-rep-of-tree-fix-cst (equal (imf-cst-domain-conc3-rep (tree-fix cst)) (imf-cst-domain-conc3-rep cst)))
Theorem:
(defthm imf-cst-domain-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc3-rep cst) (imf-cst-domain-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-left-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-id-left-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-id-left-conc1-rep (b* ((csts (imf-cst-id-left-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-rep-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)) (b* ((csts (imf-cst-id-left-conc1-rep cst))) (imf-cst-list-rep-matchp csts "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-rep-of-tree-fix-cst (equal (imf-cst-id-left-conc1-rep (tree-fix cst)) (imf-cst-id-left-conc1-rep cst)))
Theorem:
(defthm imf-cst-id-left-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc1-rep cst) (imf-cst-id-left-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-left-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-id-left-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-id-left-conc2-rep (b* ((csts (imf-cst-id-left-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-rep-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)) (b* ((csts (imf-cst-id-left-conc2-rep cst))) (imf-cst-list-rep-matchp csts "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-rep-of-tree-fix-cst (equal (imf-cst-id-left-conc2-rep (tree-fix cst)) (imf-cst-id-left-conc2-rep cst)))
Theorem:
(defthm imf-cst-id-left-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc2-rep cst) (imf-cst-id-left-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-right-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-id-right-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-id-right-conc1-rep (b* ((csts (imf-cst-id-right-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-rep-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)) (b* ((csts (imf-cst-id-right-conc1-rep cst))) (imf-cst-list-rep-matchp csts "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-rep-of-tree-fix-cst (equal (imf-cst-id-right-conc1-rep (tree-fix cst)) (imf-cst-id-right-conc1-rep cst)))
Theorem:
(defthm imf-cst-id-right-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc1-rep cst) (imf-cst-id-right-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-right-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-id-right-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-id-right-conc2-rep (b* ((csts (imf-cst-id-right-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-rep-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)) (b* ((csts (imf-cst-id-right-conc2-rep cst))) (imf-cst-list-rep-matchp csts "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-rep-of-tree-fix-cst (equal (imf-cst-id-right-conc2-rep (tree-fix cst)) (imf-cst-id-right-conc2-rep cst)))
Theorem:
(defthm imf-cst-id-right-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc2-rep cst) (imf-cst-id-right-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)))) (let ((__function__ 'imf-cst-id-right-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-id-right-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-id-right-conc3-rep (b* ((csts (imf-cst-id-right-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-rep-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)) (b* ((csts (imf-cst-id-right-conc3-rep cst))) (imf-cst-list-rep-matchp csts "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-rep-of-tree-fix-cst (equal (imf-cst-id-right-conc3-rep (tree-fix cst)) (imf-cst-id-right-conc3-rep cst)))
Theorem:
(defthm imf-cst-id-right-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc3-rep cst) (imf-cst-id-right-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)))) (let ((__function__ 'imf-cst-received-token-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-received-token-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-received-token-conc1-rep (b* ((csts (imf-cst-received-token-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-rep-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)) (b* ((csts (imf-cst-received-token-conc1-rep cst))) (imf-cst-list-rep-matchp csts "word"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-rep-of-tree-fix-cst (equal (imf-cst-received-token-conc1-rep (tree-fix cst)) (imf-cst-received-token-conc1-rep cst)))
Theorem:
(defthm imf-cst-received-token-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc1-rep cst) (imf-cst-received-token-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)))) (let ((__function__ 'imf-cst-received-token-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-received-token-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-received-token-conc2-rep (b* ((csts (imf-cst-received-token-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-rep-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)) (b* ((csts (imf-cst-received-token-conc2-rep cst))) (imf-cst-list-rep-matchp csts "angle-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-rep-of-tree-fix-cst (equal (imf-cst-received-token-conc2-rep (tree-fix cst)) (imf-cst-received-token-conc2-rep cst)))
Theorem:
(defthm imf-cst-received-token-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc2-rep cst) (imf-cst-received-token-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)))) (let ((__function__ 'imf-cst-received-token-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-received-token-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-received-token-conc3-rep (b* ((csts (imf-cst-received-token-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-rep-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)) (b* ((csts (imf-cst-received-token-conc3-rep cst))) (imf-cst-list-rep-matchp csts "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-rep-of-tree-fix-cst (equal (imf-cst-received-token-conc3-rep (tree-fix cst)) (imf-cst-received-token-conc3-rep cst)))
Theorem:
(defthm imf-cst-received-token-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc3-rep cst) (imf-cst-received-token-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)))) (let ((__function__ 'imf-cst-received-token-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-received-token-conc4 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-received-token-conc4-rep (b* ((csts (imf-cst-received-token-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-rep-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)) (b* ((csts (imf-cst-received-token-conc4-rep cst))) (imf-cst-list-rep-matchp csts "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-rep-of-tree-fix-cst (equal (imf-cst-received-token-conc4-rep (tree-fix cst)) (imf-cst-received-token-conc4-rep cst)))
Theorem:
(defthm imf-cst-received-token-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc4-rep cst) (imf-cst-received-token-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-ctext-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-ctext"))) (let ((__function__ 'imf-cst-obs-ctext-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-ctext-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-ctext-conc-rep (b* ((csts (imf-cst-obs-ctext-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-match (implies (imf-cst-matchp cst "obs-ctext") (b* ((csts (imf-cst-obs-ctext-conc-rep cst))) (imf-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-of-tree-fix-cst (equal (imf-cst-obs-ctext-conc-rep (tree-fix cst)) (imf-cst-obs-ctext-conc-rep cst)))
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-ctext-conc-rep cst) (imf-cst-obs-ctext-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-qtext-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-qtext"))) (let ((__function__ 'imf-cst-obs-qtext-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-qtext-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-qtext-conc-rep (b* ((csts (imf-cst-obs-qtext-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-match (implies (imf-cst-matchp cst "obs-qtext") (b* ((csts (imf-cst-obs-qtext-conc-rep cst))) (imf-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-of-tree-fix-cst (equal (imf-cst-obs-qtext-conc-rep (tree-fix cst)) (imf-cst-obs-qtext-conc-rep cst)))
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-qtext-conc-rep cst) (imf-cst-obs-qtext-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'imf-cst-obs-dtext-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-dtext-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-dtext-conc1-rep (b* ((csts (imf-cst-obs-dtext-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)) (b* ((csts (imf-cst-obs-dtext-conc1-rep cst))) (imf-cst-list-rep-matchp csts "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc1-rep (tree-fix cst)) (imf-cst-obs-dtext-conc1-rep cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc1-rep cst) (imf-cst-obs-dtext-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'imf-cst-obs-dtext-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-dtext-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-dtext-conc2-rep (b* ((csts (imf-cst-obs-dtext-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)) (b* ((csts (imf-cst-obs-dtext-conc2-rep cst))) (imf-cst-list-rep-matchp csts "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc2-rep (tree-fix cst)) (imf-cst-obs-dtext-conc2-rep cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc2-rep cst) (imf-cst-obs-dtext-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-left-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-left"))) (let ((__function__ 'imf-cst-obs-id-left-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-id-left-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-id-left-conc-rep (b* ((csts (imf-cst-obs-id-left-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-match (implies (imf-cst-matchp cst "obs-id-left") (b* ((csts (imf-cst-obs-id-left-conc-rep cst))) (imf-cst-list-rep-matchp csts "local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-of-tree-fix-cst (equal (imf-cst-obs-id-left-conc-rep (tree-fix cst)) (imf-cst-obs-id-left-conc-rep cst)))
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-left-conc-rep cst) (imf-cst-obs-id-left-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-right-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-right"))) (let ((__function__ 'imf-cst-obs-id-right-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-obs-id-right-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-obs-id-right-conc-rep (b* ((csts (imf-cst-obs-id-right-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-match (implies (imf-cst-matchp cst "obs-id-right") (b* ((csts (imf-cst-obs-id-right-conc-rep cst))) (imf-cst-list-rep-matchp csts "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-of-tree-fix-cst (equal (imf-cst-obs-id-right-conc-rep (tree-fix cst)) (imf-cst-obs-id-right-conc-rep cst)))
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-right-conc-rep cst) (imf-cst-obs-id-right-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-cr-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "cr"))) (let ((__function__ 'imf-cst-cr-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-cr-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-cr-conc-rep (b* ((csts (imf-cst-cr-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-rep-match (implies (imf-cst-matchp cst "cr") (b* ((csts (imf-cst-cr-conc-rep cst))) (imf-cst-list-rep-matchp csts "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-rep-of-tree-fix-cst (equal (imf-cst-cr-conc-rep (tree-fix cst)) (imf-cst-cr-conc-rep cst)))
Theorem:
(defthm imf-cst-cr-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-cr-conc-rep cst) (imf-cst-cr-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-digit-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "digit"))) (let ((__function__ 'imf-cst-digit-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-digit-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-digit-conc-rep (b* ((csts (imf-cst-digit-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-rep-match (implies (imf-cst-matchp cst "digit") (b* ((csts (imf-cst-digit-conc-rep cst))) (imf-cst-list-rep-matchp csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-rep-of-tree-fix-cst (equal (imf-cst-digit-conc-rep (tree-fix cst)) (imf-cst-digit-conc-rep cst)))
Theorem:
(defthm imf-cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-digit-conc-rep cst) (imf-cst-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-dquote-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "dquote"))) (let ((__function__ 'imf-cst-dquote-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-dquote-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-dquote-conc-rep (b* ((csts (imf-cst-dquote-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-rep-match (implies (imf-cst-matchp cst "dquote") (b* ((csts (imf-cst-dquote-conc-rep cst))) (imf-cst-list-rep-matchp csts "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-rep-of-tree-fix-cst (equal (imf-cst-dquote-conc-rep (tree-fix cst)) (imf-cst-dquote-conc-rep cst)))
Theorem:
(defthm imf-cst-dquote-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-dquote-conc-rep cst) (imf-cst-dquote-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-lf-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "lf"))) (let ((__function__ 'imf-cst-lf-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-lf-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-lf-conc-rep (b* ((csts (imf-cst-lf-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-rep-match (implies (imf-cst-matchp cst "lf") (b* ((csts (imf-cst-lf-conc-rep cst))) (imf-cst-list-rep-matchp csts "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-rep-of-tree-fix-cst (equal (imf-cst-lf-conc-rep (tree-fix cst)) (imf-cst-lf-conc-rep cst)))
Theorem:
(defthm imf-cst-lf-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-lf-conc-rep cst) (imf-cst-lf-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-vchar-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "vchar"))) (let ((__function__ 'imf-cst-vchar-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-vchar-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-vchar-conc-rep (b* ((csts (imf-cst-vchar-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-rep-match (implies (imf-cst-matchp cst "vchar") (b* ((csts (imf-cst-vchar-conc-rep cst))) (imf-cst-list-rep-matchp csts "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-rep-of-tree-fix-cst (equal (imf-cst-vchar-conc-rep (tree-fix cst)) (imf-cst-vchar-conc-rep cst)))
Theorem:
(defthm imf-cst-vchar-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-vchar-conc-rep cst) (imf-cst-vchar-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)))) (let ((__function__ 'imf-cst-wsp-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-wsp-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-wsp-conc1-rep (b* ((csts (imf-cst-wsp-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-rep-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)) (b* ((csts (imf-cst-wsp-conc1-rep cst))) (imf-cst-list-rep-matchp csts "sp"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-rep-of-tree-fix-cst (equal (imf-cst-wsp-conc1-rep (tree-fix cst)) (imf-cst-wsp-conc1-rep cst)))
Theorem:
(defthm imf-cst-wsp-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc1-rep cst) (imf-cst-wsp-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)))) (let ((__function__ 'imf-cst-wsp-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-wsp-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-wsp-conc2-rep (b* ((csts (imf-cst-wsp-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-rep-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)) (b* ((csts (imf-cst-wsp-conc2-rep cst))) (imf-cst-list-rep-matchp csts "htab"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-rep-of-tree-fix-cst (equal (imf-cst-wsp-conc2-rep (tree-fix cst)) (imf-cst-wsp-conc2-rep cst)))
Theorem:
(defthm imf-cst-wsp-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc2-rep cst) (imf-cst-wsp-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-htab-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "htab"))) (let ((__function__ 'imf-cst-htab-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-htab-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-htab-conc-rep (b* ((csts (imf-cst-htab-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-rep-match (implies (imf-cst-matchp cst "htab") (b* ((csts (imf-cst-htab-conc-rep cst))) (imf-cst-list-rep-matchp csts "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-rep-of-tree-fix-cst (equal (imf-cst-htab-conc-rep (tree-fix cst)) (imf-cst-htab-conc-rep cst)))
Theorem:
(defthm imf-cst-htab-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-htab-conc-rep cst) (imf-cst-htab-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-sp-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "sp"))) (let ((__function__ 'imf-cst-sp-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imf-cst-sp-conc cst)))))
Theorem:
(defthm tree-listp-of-imf-cst-sp-conc-rep (b* ((csts (imf-cst-sp-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-rep-match (implies (imf-cst-matchp cst "sp") (b* ((csts (imf-cst-sp-conc-rep cst))) (imf-cst-list-rep-matchp csts "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-rep-of-tree-fix-cst (equal (imf-cst-sp-conc-rep (tree-fix cst)) (imf-cst-sp-conc-rep cst)))
Theorem:
(defthm imf-cst-sp-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-sp-conc-rep cst) (imf-cst-sp-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-ccontent-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-ccontent-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-ccontent-conc1-rep-elem (b* ((cst1 (imf-cst-ccontent-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 1)) (b* ((cst1 (imf-cst-ccontent-conc1-rep-elem cst))) (imf-cst-matchp cst1 "ctext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-ccontent-conc1-rep-elem (tree-fix cst)) (imf-cst-ccontent-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-ccontent-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc1-rep-elem cst) (imf-cst-ccontent-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-ccontent-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-ccontent-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-ccontent-conc2-rep-elem (b* ((cst1 (imf-cst-ccontent-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 2)) (b* ((cst1 (imf-cst-ccontent-conc2-rep-elem cst))) (imf-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-ccontent-conc2-rep-elem (tree-fix cst)) (imf-cst-ccontent-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-ccontent-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc2-rep-elem cst) (imf-cst-ccontent-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-ccontent-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)))) (let ((__function__ 'imf-cst-ccontent-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-ccontent-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-ccontent-conc3-rep-elem (b* ((cst1 (imf-cst-ccontent-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "ccontent") (equal (imf-cst-ccontent-conc? cst) 3)) (b* ((cst1 (imf-cst-ccontent-conc3-rep-elem cst))) (imf-cst-matchp cst1 "comment"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-ccontent-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-ccontent-conc3-rep-elem (tree-fix cst)) (imf-cst-ccontent-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-ccontent-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-ccontent-conc3-rep-elem cst) (imf-cst-ccontent-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)))) (let ((__function__ 'imf-cst-qcontent-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-qcontent-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-qcontent-conc1-rep-elem (b* ((cst1 (imf-cst-qcontent-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 1)) (b* ((cst1 (imf-cst-qcontent-conc1-rep-elem cst))) (imf-cst-matchp cst1 "qtext"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-qcontent-conc1-rep-elem (tree-fix cst)) (imf-cst-qcontent-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-qcontent-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc1-rep-elem cst) (imf-cst-qcontent-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-qcontent-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)))) (let ((__function__ 'imf-cst-qcontent-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-qcontent-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-qcontent-conc2-rep-elem (b* ((cst1 (imf-cst-qcontent-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "qcontent") (equal (imf-cst-qcontent-conc? cst) 2)) (b* ((cst1 (imf-cst-qcontent-conc2-rep-elem cst))) (imf-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-qcontent-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-qcontent-conc2-rep-elem (tree-fix cst)) (imf-cst-qcontent-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-qcontent-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-qcontent-conc2-rep-elem cst) (imf-cst-qcontent-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)))) (let ((__function__ 'imf-cst-word-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-word-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-word-conc1-rep-elem (b* ((cst1 (imf-cst-word-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 1)) (b* ((cst1 (imf-cst-word-conc1-rep-elem cst))) (imf-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-word-conc1-rep-elem (tree-fix cst)) (imf-cst-word-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-word-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc1-rep-elem cst) (imf-cst-word-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-word-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)))) (let ((__function__ 'imf-cst-word-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-word-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-word-conc2-rep-elem (b* ((cst1 (imf-cst-word-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "word") (equal (imf-cst-word-conc? cst) 2)) (b* ((cst1 (imf-cst-word-conc2-rep-elem cst))) (imf-cst-matchp cst1 "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-word-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-word-conc2-rep-elem (tree-fix cst)) (imf-cst-word-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-word-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-word-conc2-rep-elem cst) (imf-cst-word-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)))) (let ((__function__ 'imf-cst-address-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-address-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-address-conc1-rep-elem (b* ((cst1 (imf-cst-address-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 1)) (b* ((cst1 (imf-cst-address-conc1-rep-elem cst))) (imf-cst-matchp cst1 "mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-address-conc1-rep-elem (tree-fix cst)) (imf-cst-address-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-address-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc1-rep-elem cst) (imf-cst-address-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-address-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)))) (let ((__function__ 'imf-cst-address-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-address-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-address-conc2-rep-elem (b* ((cst1 (imf-cst-address-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "address") (equal (imf-cst-address-conc? cst) 2)) (b* ((cst1 (imf-cst-address-conc2-rep-elem cst))) (imf-cst-matchp cst1 "group"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-address-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-address-conc2-rep-elem (tree-fix cst)) (imf-cst-address-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-address-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-address-conc2-rep-elem cst) (imf-cst-address-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)))) (let ((__function__ 'imf-cst-mailbox-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-mailbox-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-mailbox-conc1-rep-elem (b* ((cst1 (imf-cst-mailbox-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 1)) (b* ((cst1 (imf-cst-mailbox-conc1-rep-elem cst))) (imf-cst-matchp cst1 "name-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-mailbox-conc1-rep-elem (tree-fix cst)) (imf-cst-mailbox-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-mailbox-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc1-rep-elem cst) (imf-cst-mailbox-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-mailbox-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)))) (let ((__function__ 'imf-cst-mailbox-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-mailbox-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-mailbox-conc2-rep-elem (b* ((cst1 (imf-cst-mailbox-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "mailbox") (equal (imf-cst-mailbox-conc? cst) 2)) (b* ((cst1 (imf-cst-mailbox-conc2-rep-elem cst))) (imf-cst-matchp cst1 "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-mailbox-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-mailbox-conc2-rep-elem (tree-fix cst)) (imf-cst-mailbox-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-mailbox-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-mailbox-conc2-rep-elem cst) (imf-cst-mailbox-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-display-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "display-name"))) (let ((__function__ 'imf-cst-display-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-display-name-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-display-name-conc-rep-elem (b* ((cst1 (imf-cst-display-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-rep-elem-match (implies (imf-cst-matchp cst "display-name") (b* ((cst1 (imf-cst-display-name-conc-rep-elem cst))) (imf-cst-matchp cst1 "phrase"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-display-name-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-display-name-conc-rep-elem (tree-fix cst)) (imf-cst-display-name-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-display-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-display-name-conc-rep-elem cst) (imf-cst-display-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)))) (let ((__function__ 'imf-cst-group-list-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-group-list-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-group-list-conc1-rep-elem (b* ((cst1 (imf-cst-group-list-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 1)) (b* ((cst1 (imf-cst-group-list-conc1-rep-elem cst))) (imf-cst-matchp cst1 "mailbox-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-group-list-conc1-rep-elem (tree-fix cst)) (imf-cst-group-list-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-group-list-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc1-rep-elem cst) (imf-cst-group-list-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)))) (let ((__function__ 'imf-cst-group-list-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-group-list-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-group-list-conc2-rep-elem (b* ((cst1 (imf-cst-group-list-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 2)) (b* ((cst1 (imf-cst-group-list-conc2-rep-elem cst))) (imf-cst-matchp cst1 "cfws"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-group-list-conc2-rep-elem (tree-fix cst)) (imf-cst-group-list-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-group-list-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc2-rep-elem cst) (imf-cst-group-list-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-group-list-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)))) (let ((__function__ 'imf-cst-group-list-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-group-list-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-group-list-conc3-rep-elem (b* ((cst1 (imf-cst-group-list-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "group-list") (equal (imf-cst-group-list-conc? cst) 3)) (b* ((cst1 (imf-cst-group-list-conc3-rep-elem cst))) (imf-cst-matchp cst1 "obs-group-list"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-group-list-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-group-list-conc3-rep-elem (tree-fix cst)) (imf-cst-group-list-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-group-list-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-group-list-conc3-rep-elem cst) (imf-cst-group-list-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)))) (let ((__function__ 'imf-cst-local-part-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-local-part-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-local-part-conc1-rep-elem (b* ((cst1 (imf-cst-local-part-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 1)) (b* ((cst1 (imf-cst-local-part-conc1-rep-elem cst))) (imf-cst-matchp cst1 "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-local-part-conc1-rep-elem (tree-fix cst)) (imf-cst-local-part-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc1-rep-elem cst) (imf-cst-local-part-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)))) (let ((__function__ 'imf-cst-local-part-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-local-part-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-local-part-conc2-rep-elem (b* ((cst1 (imf-cst-local-part-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 2)) (b* ((cst1 (imf-cst-local-part-conc2-rep-elem cst))) (imf-cst-matchp cst1 "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-local-part-conc2-rep-elem (tree-fix cst)) (imf-cst-local-part-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc2-rep-elem cst) (imf-cst-local-part-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-local-part-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)))) (let ((__function__ 'imf-cst-local-part-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-local-part-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-local-part-conc3-rep-elem (b* ((cst1 (imf-cst-local-part-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "local-part") (equal (imf-cst-local-part-conc? cst) 3)) (b* ((cst1 (imf-cst-local-part-conc3-rep-elem cst))) (imf-cst-matchp cst1 "obs-local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-local-part-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-local-part-conc3-rep-elem (tree-fix cst)) (imf-cst-local-part-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-local-part-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-local-part-conc3-rep-elem cst) (imf-cst-local-part-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)))) (let ((__function__ 'imf-cst-domain-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-domain-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-domain-conc1-rep-elem (b* ((cst1 (imf-cst-domain-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 1)) (b* ((cst1 (imf-cst-domain-conc1-rep-elem cst))) (imf-cst-matchp cst1 "dot-atom"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-domain-conc1-rep-elem (tree-fix cst)) (imf-cst-domain-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-domain-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc1-rep-elem cst) (imf-cst-domain-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)))) (let ((__function__ 'imf-cst-domain-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-domain-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-domain-conc2-rep-elem (b* ((cst1 (imf-cst-domain-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 2)) (b* ((cst1 (imf-cst-domain-conc2-rep-elem cst))) (imf-cst-matchp cst1 "domain-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-domain-conc2-rep-elem (tree-fix cst)) (imf-cst-domain-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-domain-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc2-rep-elem cst) (imf-cst-domain-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-domain-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)))) (let ((__function__ 'imf-cst-domain-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-domain-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-domain-conc3-rep-elem (b* ((cst1 (imf-cst-domain-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "domain") (equal (imf-cst-domain-conc? cst) 3)) (b* ((cst1 (imf-cst-domain-conc3-rep-elem cst))) (imf-cst-matchp cst1 "obs-domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-domain-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-domain-conc3-rep-elem (tree-fix cst)) (imf-cst-domain-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-domain-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-domain-conc3-rep-elem cst) (imf-cst-domain-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-left-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-id-left-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-id-left-conc1-rep-elem (b* ((cst1 (imf-cst-id-left-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 1)) (b* ((cst1 (imf-cst-id-left-conc1-rep-elem cst))) (imf-cst-matchp cst1 "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-id-left-conc1-rep-elem (tree-fix cst)) (imf-cst-id-left-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-id-left-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc1-rep-elem cst) (imf-cst-id-left-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-left-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-left-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-id-left-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-id-left-conc2-rep-elem (b* ((cst1 (imf-cst-id-left-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "id-left") (equal (imf-cst-id-left-conc? cst) 2)) (b* ((cst1 (imf-cst-id-left-conc2-rep-elem cst))) (imf-cst-matchp cst1 "obs-id-left"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-left-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-id-left-conc2-rep-elem (tree-fix cst)) (imf-cst-id-left-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-id-left-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-left-conc2-rep-elem cst) (imf-cst-id-left-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)))) (let ((__function__ 'imf-cst-id-right-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-id-right-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-id-right-conc1-rep-elem (b* ((cst1 (imf-cst-id-right-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 1)) (b* ((cst1 (imf-cst-id-right-conc1-rep-elem cst))) (imf-cst-matchp cst1 "dot-atom-text"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-id-right-conc1-rep-elem (tree-fix cst)) (imf-cst-id-right-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-id-right-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc1-rep-elem cst) (imf-cst-id-right-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)))) (let ((__function__ 'imf-cst-id-right-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-id-right-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-id-right-conc2-rep-elem (b* ((cst1 (imf-cst-id-right-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 2)) (b* ((cst1 (imf-cst-id-right-conc2-rep-elem cst))) (imf-cst-matchp cst1 "no-fold-literal"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-id-right-conc2-rep-elem (tree-fix cst)) (imf-cst-id-right-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-id-right-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc2-rep-elem cst) (imf-cst-id-right-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-id-right-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)))) (let ((__function__ 'imf-cst-id-right-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-id-right-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-id-right-conc3-rep-elem (b* ((cst1 (imf-cst-id-right-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "id-right") (equal (imf-cst-id-right-conc? cst) 3)) (b* ((cst1 (imf-cst-id-right-conc3-rep-elem cst))) (imf-cst-matchp cst1 "obs-id-right"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-id-right-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-id-right-conc3-rep-elem (tree-fix cst)) (imf-cst-id-right-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-id-right-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-id-right-conc3-rep-elem cst) (imf-cst-id-right-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)))) (let ((__function__ 'imf-cst-received-token-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-received-token-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-received-token-conc1-rep-elem (b* ((cst1 (imf-cst-received-token-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 1)) (b* ((cst1 (imf-cst-received-token-conc1-rep-elem cst))) (imf-cst-matchp cst1 "word"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-received-token-conc1-rep-elem (tree-fix cst)) (imf-cst-received-token-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-received-token-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc1-rep-elem cst) (imf-cst-received-token-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)))) (let ((__function__ 'imf-cst-received-token-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-received-token-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-received-token-conc2-rep-elem (b* ((cst1 (imf-cst-received-token-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 2)) (b* ((cst1 (imf-cst-received-token-conc2-rep-elem cst))) (imf-cst-matchp cst1 "angle-addr"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-received-token-conc2-rep-elem (tree-fix cst)) (imf-cst-received-token-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-received-token-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc2-rep-elem cst) (imf-cst-received-token-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)))) (let ((__function__ 'imf-cst-received-token-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-received-token-conc3-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-received-token-conc3-rep-elem (b* ((cst1 (imf-cst-received-token-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-rep-elem-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 3)) (b* ((cst1 (imf-cst-received-token-conc3-rep-elem cst))) (imf-cst-matchp cst1 "addr-spec"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc3-rep-elem-of-tree-fix-cst (equal (imf-cst-received-token-conc3-rep-elem (tree-fix cst)) (imf-cst-received-token-conc3-rep-elem cst)))
Theorem:
(defthm imf-cst-received-token-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc3-rep-elem cst) (imf-cst-received-token-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-received-token-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)))) (let ((__function__ 'imf-cst-received-token-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-received-token-conc4-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-received-token-conc4-rep-elem (b* ((cst1 (imf-cst-received-token-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-rep-elem-match (implies (and (imf-cst-matchp cst "received-token") (equal (imf-cst-received-token-conc? cst) 4)) (b* ((cst1 (imf-cst-received-token-conc4-rep-elem cst))) (imf-cst-matchp cst1 "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-received-token-conc4-rep-elem-of-tree-fix-cst (equal (imf-cst-received-token-conc4-rep-elem (tree-fix cst)) (imf-cst-received-token-conc4-rep-elem cst)))
Theorem:
(defthm imf-cst-received-token-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-received-token-conc4-rep-elem cst) (imf-cst-received-token-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-ctext-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-ctext"))) (let ((__function__ 'imf-cst-obs-ctext-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-ctext-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-ctext-conc-rep-elem (b* ((cst1 (imf-cst-obs-ctext-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-elem-match (implies (imf-cst-matchp cst "obs-ctext") (b* ((cst1 (imf-cst-obs-ctext-conc-rep-elem cst))) (imf-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-ctext-conc-rep-elem (tree-fix cst)) (imf-cst-obs-ctext-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-ctext-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-ctext-conc-rep-elem cst) (imf-cst-obs-ctext-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-qtext-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-qtext"))) (let ((__function__ 'imf-cst-obs-qtext-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-qtext-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-qtext-conc-rep-elem (b* ((cst1 (imf-cst-obs-qtext-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-elem-match (implies (imf-cst-matchp cst "obs-qtext") (b* ((cst1 (imf-cst-obs-qtext-conc-rep-elem cst))) (imf-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-qtext-conc-rep-elem (tree-fix cst)) (imf-cst-obs-qtext-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-qtext-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-qtext-conc-rep-elem cst) (imf-cst-obs-qtext-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)))) (let ((__function__ 'imf-cst-obs-dtext-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-dtext-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-dtext-conc1-rep-elem (b* ((cst1 (imf-cst-obs-dtext-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 1)) (b* ((cst1 (imf-cst-obs-dtext-conc1-rep-elem cst))) (imf-cst-matchp cst1 "obs-no-ws-ctl"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc1-rep-elem (tree-fix cst)) (imf-cst-obs-dtext-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc1-rep-elem cst) (imf-cst-obs-dtext-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-dtext-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)))) (let ((__function__ 'imf-cst-obs-dtext-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-dtext-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-dtext-conc2-rep-elem (b* ((cst1 (imf-cst-obs-dtext-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "obs-dtext") (equal (imf-cst-obs-dtext-conc? cst) 2)) (b* ((cst1 (imf-cst-obs-dtext-conc2-rep-elem cst))) (imf-cst-matchp cst1 "quoted-pair"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-dtext-conc2-rep-elem (tree-fix cst)) (imf-cst-obs-dtext-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-dtext-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-dtext-conc2-rep-elem cst) (imf-cst-obs-dtext-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-left-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-left"))) (let ((__function__ 'imf-cst-obs-id-left-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-id-left-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-id-left-conc-rep-elem (b* ((cst1 (imf-cst-obs-id-left-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-elem-match (implies (imf-cst-matchp cst "obs-id-left") (b* ((cst1 (imf-cst-obs-id-left-conc-rep-elem cst))) (imf-cst-matchp cst1 "local-part"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-id-left-conc-rep-elem (tree-fix cst)) (imf-cst-obs-id-left-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-id-left-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-left-conc-rep-elem cst) (imf-cst-obs-id-left-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-obs-id-right-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "obs-id-right"))) (let ((__function__ 'imf-cst-obs-id-right-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-obs-id-right-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-obs-id-right-conc-rep-elem (b* ((cst1 (imf-cst-obs-id-right-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-elem-match (implies (imf-cst-matchp cst "obs-id-right") (b* ((cst1 (imf-cst-obs-id-right-conc-rep-elem cst))) (imf-cst-matchp cst1 "domain"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-obs-id-right-conc-rep-elem (tree-fix cst)) (imf-cst-obs-id-right-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-obs-id-right-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-obs-id-right-conc-rep-elem cst) (imf-cst-obs-id-right-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-cr-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "cr"))) (let ((__function__ 'imf-cst-cr-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-cr-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-cr-conc-rep-elem (b* ((cst1 (imf-cst-cr-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-rep-elem-match (implies (imf-cst-matchp cst "cr") (b* ((cst1 (imf-cst-cr-conc-rep-elem cst))) (imf-cst-matchp cst1 "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-cr-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-cr-conc-rep-elem (tree-fix cst)) (imf-cst-cr-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-cr-conc-rep-elem cst) (imf-cst-cr-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-digit-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "digit"))) (let ((__function__ 'imf-cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-digit-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-digit-conc-rep-elem (b* ((cst1 (imf-cst-digit-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-rep-elem-match (implies (imf-cst-matchp cst "digit") (b* ((cst1 (imf-cst-digit-conc-rep-elem cst))) (imf-cst-matchp cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-digit-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-digit-conc-rep-elem (tree-fix cst)) (imf-cst-digit-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-digit-conc-rep-elem cst) (imf-cst-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-dquote-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "dquote"))) (let ((__function__ 'imf-cst-dquote-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-dquote-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-dquote-conc-rep-elem (b* ((cst1 (imf-cst-dquote-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-rep-elem-match (implies (imf-cst-matchp cst "dquote") (b* ((cst1 (imf-cst-dquote-conc-rep-elem cst))) (imf-cst-matchp cst1 "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-dquote-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-dquote-conc-rep-elem (tree-fix cst)) (imf-cst-dquote-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-dquote-conc-rep-elem cst) (imf-cst-dquote-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-lf-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "lf"))) (let ((__function__ 'imf-cst-lf-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-lf-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-lf-conc-rep-elem (b* ((cst1 (imf-cst-lf-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-rep-elem-match (implies (imf-cst-matchp cst "lf") (b* ((cst1 (imf-cst-lf-conc-rep-elem cst))) (imf-cst-matchp cst1 "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-lf-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-lf-conc-rep-elem (tree-fix cst)) (imf-cst-lf-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-lf-conc-rep-elem cst) (imf-cst-lf-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-vchar-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "vchar"))) (let ((__function__ 'imf-cst-vchar-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-vchar-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-vchar-conc-rep-elem (b* ((cst1 (imf-cst-vchar-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-rep-elem-match (implies (imf-cst-matchp cst "vchar") (b* ((cst1 (imf-cst-vchar-conc-rep-elem cst))) (imf-cst-matchp cst1 "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-vchar-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-vchar-conc-rep-elem (tree-fix cst)) (imf-cst-vchar-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-vchar-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-vchar-conc-rep-elem cst) (imf-cst-vchar-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)))) (let ((__function__ 'imf-cst-wsp-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-wsp-conc1-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-wsp-conc1-rep-elem (b* ((cst1 (imf-cst-wsp-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-rep-elem-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 1)) (b* ((cst1 (imf-cst-wsp-conc1-rep-elem cst))) (imf-cst-matchp cst1 "sp"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc1-rep-elem-of-tree-fix-cst (equal (imf-cst-wsp-conc1-rep-elem (tree-fix cst)) (imf-cst-wsp-conc1-rep-elem cst)))
Theorem:
(defthm imf-cst-wsp-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc1-rep-elem cst) (imf-cst-wsp-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-wsp-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)))) (let ((__function__ 'imf-cst-wsp-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-wsp-conc2-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-wsp-conc2-rep-elem (b* ((cst1 (imf-cst-wsp-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-rep-elem-match (implies (and (imf-cst-matchp cst "wsp") (equal (imf-cst-wsp-conc? cst) 2)) (b* ((cst1 (imf-cst-wsp-conc2-rep-elem cst))) (imf-cst-matchp cst1 "htab"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-wsp-conc2-rep-elem-of-tree-fix-cst (equal (imf-cst-wsp-conc2-rep-elem (tree-fix cst)) (imf-cst-wsp-conc2-rep-elem cst)))
Theorem:
(defthm imf-cst-wsp-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-wsp-conc2-rep-elem cst) (imf-cst-wsp-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-htab-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "htab"))) (let ((__function__ 'imf-cst-htab-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-htab-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-htab-conc-rep-elem (b* ((cst1 (imf-cst-htab-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-rep-elem-match (implies (imf-cst-matchp cst "htab") (b* ((cst1 (imf-cst-htab-conc-rep-elem cst))) (imf-cst-matchp cst1 "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-htab-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-htab-conc-rep-elem (tree-fix cst)) (imf-cst-htab-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-htab-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-htab-conc-rep-elem cst) (imf-cst-htab-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imf-cst-sp-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imf-cst-matchp cst "sp"))) (let ((__function__ 'imf-cst-sp-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imf-cst-sp-conc-rep cst)))))
Theorem:
(defthm treep-of-imf-cst-sp-conc-rep-elem (b* ((cst1 (imf-cst-sp-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-rep-elem-match (implies (imf-cst-matchp cst "sp") (b* ((cst1 (imf-cst-sp-conc-rep-elem cst))) (imf-cst-matchp cst1 "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imf-cst-sp-conc-rep-elem-of-tree-fix-cst (equal (imf-cst-sp-conc-rep-elem (tree-fix cst)) (imf-cst-sp-conc-rep-elem cst)))
Theorem:
(defthm imf-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imf-cst-sp-conc-rep-elem cst) (imf-cst-sp-conc-rep-elem cst-equiv))) :rule-classes :congruence)