Tree operations specialized to *all-imap-grammar-rules*.
Function:
(defun imap-cst-matchp$ (tree elem) (declare (xargs :guard (and (treep tree) (elementp elem)))) (let ((__function__ 'imap-cst-matchp$)) (declare (ignorable __function__)) (and (tree-terminatedp tree) (tree-match-element-p tree elem *all-imap-grammar-rules*))))
Theorem:
(defthm booleanp-of-imap-cst-matchp$ (b* ((yes/no (imap-cst-matchp$ tree elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-matchp$-of-tree-fix-tree (equal (imap-cst-matchp$ (tree-fix tree) elem) (imap-cst-matchp$ tree elem)))
Theorem:
(defthm imap-cst-matchp$-tree-equiv-congruence-on-tree (implies (tree-equiv tree tree-equiv) (equal (imap-cst-matchp$ tree elem) (imap-cst-matchp$ tree-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-matchp$-of-element-fix-elem (equal (imap-cst-matchp$ tree (element-fix elem)) (imap-cst-matchp$ tree elem)))
Theorem:
(defthm imap-cst-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (imap-cst-matchp$ tree elem) (imap-cst-matchp$ tree elem-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-elem-matchp$ (trees elem) (declare (xargs :guard (and (tree-listp trees) (elementp elem)))) (let ((__function__ 'imap-cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-element-p trees elem *all-imap-grammar-rules*))))
Theorem:
(defthm booleanp-of-imap-cst-list-elem-matchp$ (b* ((yes/no (imap-cst-list-elem-matchp$ trees elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-elem-matchp$-of-tree-list-fix-trees (equal (imap-cst-list-elem-matchp$ (tree-list-fix trees) elem) (imap-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm imap-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (imap-cst-list-elem-matchp$ trees elem) (imap-cst-list-elem-matchp$ trees-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-list-elem-matchp$-of-element-fix-elem (equal (imap-cst-list-elem-matchp$ trees (element-fix elem)) (imap-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm imap-cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (imap-cst-list-elem-matchp$ trees elem) (imap-cst-list-elem-matchp$ trees elem-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-rep-matchp$ (trees rep) (declare (xargs :guard (and (tree-listp trees) (repetitionp rep)))) (let ((__function__ 'imap-cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-repetition-p trees rep *all-imap-grammar-rules*))))
Theorem:
(defthm booleanp-of-imap-cst-list-rep-matchp$ (b* ((yes/no (imap-cst-list-rep-matchp$ trees rep))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-rep-matchp$-of-tree-list-fix-trees (equal (imap-cst-list-rep-matchp$ (tree-list-fix trees) rep) (imap-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm imap-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (imap-cst-list-rep-matchp$ trees rep) (imap-cst-list-rep-matchp$ trees-equiv rep))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-list-rep-matchp$-of-repetition-fix-rep (equal (imap-cst-list-rep-matchp$ trees (repetition-fix rep)) (imap-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm imap-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (repetition-equiv rep rep-equiv) (equal (imap-cst-list-rep-matchp$ trees rep) (imap-cst-list-rep-matchp$ trees rep-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-list-conc-matchp$ (treess conc) (declare (xargs :guard (and (tree-list-listp treess) (concatenationp conc)))) (let ((__function__ 'imap-cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-concatenation-p treess conc *all-imap-grammar-rules*))))
Theorem:
(defthm booleanp-of-imap-cst-list-list-conc-matchp$ (b* ((yes/no (imap-cst-list-list-conc-matchp$ treess conc))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (imap-cst-list-list-conc-matchp$ (tree-list-list-fix treess) conc) (imap-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm imap-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (imap-cst-list-list-conc-matchp$ treess conc) (imap-cst-list-list-conc-matchp$ treess-equiv conc))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (imap-cst-list-list-conc-matchp$ treess (concatenation-fix conc)) (imap-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm imap-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (concatenation-equiv conc conc-equiv) (equal (imap-cst-list-list-conc-matchp$ treess conc) (imap-cst-list-list-conc-matchp$ treess conc-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-list-alt-matchp$ (treess alt) (declare (xargs :guard (and (tree-list-listp treess) (alternationp alt)))) (let ((__function__ 'imap-cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-alternation-p treess alt *all-imap-grammar-rules*))))
Theorem:
(defthm booleanp-of-imap-cst-list-list-alt-matchp$ (b* ((yes/no (imap-cst-list-list-alt-matchp$ treess alt))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (imap-cst-list-list-alt-matchp$ (tree-list-list-fix treess) alt) (imap-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm imap-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (imap-cst-list-list-alt-matchp$ treess alt) (imap-cst-list-list-alt-matchp$ treess-equiv alt))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (imap-cst-list-list-alt-matchp$ treess (alternation-fix alt)) (imap-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm imap-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (alternation-equiv alt alt-equiv) (equal (imap-cst-list-list-alt-matchp$ treess alt) (imap-cst-list-list-alt-matchp$ treess alt-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x0-1f-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x0-1F"))) (let ((__function__ 'imap-cst-%x0-1f-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x0-1f-nat (b* ((nat (imap-cst-%x0-1f-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x0-1f-nat-of-tree-fix-cst (equal (imap-cst-%x0-1f-nat (tree-fix cst)) (imap-cst-%x0-1f-nat cst)))
Theorem:
(defthm imap-cst-%x0-1f-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x0-1f-nat cst) (imap-cst-%x0-1f-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x1-ff-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x1-FF"))) (let ((__function__ 'imap-cst-%x1-ff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x1-ff-nat (b* ((nat (imap-cst-%x1-ff-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x1-ff-nat-of-tree-fix-cst (equal (imap-cst-%x1-ff-nat (tree-fix cst)) (imap-cst-%x1-ff-nat cst)))
Theorem:
(defthm imap-cst-%x1-ff-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x1-ff-nat cst) (imap-cst-%x1-ff-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x30-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x30-39"))) (let ((__function__ 'imap-cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x30-39-nat (b* ((nat (imap-cst-%x30-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x30-39-nat-of-tree-fix-cst (equal (imap-cst-%x30-39-nat (tree-fix cst)) (imap-cst-%x30-39-nat cst)))
Theorem:
(defthm imap-cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x30-39-nat cst) (imap-cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x31-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x31-39"))) (let ((__function__ 'imap-cst-%x31-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x31-39-nat (b* ((nat (imap-cst-%x31-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x31-39-nat-of-tree-fix-cst (equal (imap-cst-%x31-39-nat (tree-fix cst)) (imap-cst-%x31-39-nat cst)))
Theorem:
(defthm imap-cst-%x31-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x31-39-nat cst) (imap-cst-%x31-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x41-5a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x41-5A"))) (let ((__function__ 'imap-cst-%x41-5a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x41-5a-nat (b* ((nat (imap-cst-%x41-5a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x41-5a-nat-of-tree-fix-cst (equal (imap-cst-%x41-5a-nat (tree-fix cst)) (imap-cst-%x41-5a-nat cst)))
Theorem:
(defthm imap-cst-%x41-5a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x41-5a-nat cst) (imap-cst-%x41-5a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-%x61-7a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "%x61-7A"))) (let ((__function__ 'imap-cst-%x61-7a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-imap-cst-%x61-7a-nat (b* ((nat (imap-cst-%x61-7a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-%x61-7a-nat-of-tree-fix-cst (equal (imap-cst-%x61-7a-nat (tree-fix cst)) (imap-cst-%x61-7a-nat cst)))
Theorem:
(defthm imap-cst-%x61-7a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-%x61-7a-nat cst) (imap-cst-%x61-7a-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-%x0-1f-nat-bounds (implies (imap-cst-matchp cst "%x0-1F") (and (<= 0 (imap-cst-%x0-1f-nat cst)) (<= (imap-cst-%x0-1f-nat cst) 31))) :rule-classes :linear)
Theorem:
(defthm imap-cst-%x1-ff-nat-bounds (implies (imap-cst-matchp cst "%x1-FF") (and (<= 1 (imap-cst-%x1-ff-nat cst)) (<= (imap-cst-%x1-ff-nat cst) 255))) :rule-classes :linear)
Theorem:
(defthm imap-cst-%x30-39-nat-bounds (implies (imap-cst-matchp cst "%x30-39") (and (<= 48 (imap-cst-%x30-39-nat cst)) (<= (imap-cst-%x30-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm imap-cst-%x31-39-nat-bounds (implies (imap-cst-matchp cst "%x31-39") (and (<= 49 (imap-cst-%x31-39-nat cst)) (<= (imap-cst-%x31-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm imap-cst-%x41-5a-nat-bounds (implies (imap-cst-matchp cst "%x41-5A") (and (<= 65 (imap-cst-%x41-5a-nat cst)) (<= (imap-cst-%x41-5a-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm imap-cst-%x61-7a-nat-bounds (implies (imap-cst-matchp cst "%x61-7A") (and (<= 97 (imap-cst-%x61-7a-nat cst)) (<= (imap-cst-%x61-7a-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm |IMAP-CST-"%"-LEAFTERM| (implies (imap-cst-matchp cst "\"%\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"("-LEAFTERM| (implies (imap-cst-matchp cst "\"(\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-")"-LEAFTERM| (implies (imap-cst-matchp cst "\")\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"*"-LEAFTERM| (implies (imap-cst-matchp cst "\"*\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"+"-LEAFTERM| (implies (imap-cst-matchp cst "\"+\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-","-LEAFTERM| (implies (imap-cst-matchp cst "\",\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"-"-LEAFTERM| (implies (imap-cst-matchp cst "\"-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"."-LEAFTERM| (implies (imap-cst-matchp cst "\".\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-".HEADER"-LEAFTERM| (implies (imap-cst-matchp cst "\".HEADER\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-".NOT"-LEAFTERM| (implies (imap-cst-matchp cst "\".NOT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-".SILENT"-LEAFTERM| (implies (imap-cst-matchp cst "\".SILENT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-".SIZE"-LEAFTERM| (implies (imap-cst-matchp cst "\".SIZE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-".TEXT"-LEAFTERM| (implies (imap-cst-matchp cst "\".TEXT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"/"-LEAFTERM| (implies (imap-cst-matchp cst "\"/\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"7BIT"-LEAFTERM| (implies (imap-cst-matchp cst "\"7BIT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"8BIT"-LEAFTERM| (implies (imap-cst-matchp cst "\"8BIT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-":"-LEAFTERM| (implies (imap-cst-matchp cst "\":\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"<"-LEAFTERM| (implies (imap-cst-matchp cst "\"<\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"="-LEAFTERM| (implies (imap-cst-matchp cst "\"=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"=="-LEAFTERM| (implies (imap-cst-matchp cst "\"==\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-">"-LEAFTERM| (implies (imap-cst-matchp cst "\">\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"ALERT"-LEAFTERM| (implies (imap-cst-matchp cst "\"ALERT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"ALL"-LEAFTERM| (implies (imap-cst-matchp cst "\"ALL\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"ANSWERED"-LEAFTERM| (implies (imap-cst-matchp cst "\"ANSWERED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"APPEND"-LEAFTERM| (implies (imap-cst-matchp cst "\"APPEND\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"APPLICATION"-LEAFTERM| (implies (imap-cst-matchp cst "\"APPLICATION\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"AUDIO"-LEAFTERM| (implies (imap-cst-matchp cst "\"AUDIO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"AUTH="-LEAFTERM| (implies (imap-cst-matchp cst "\"AUTH=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"AUTHENTICATE"-LEAFTERM| (implies (imap-cst-matchp cst "\"AUTHENTICATE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Apr"-LEAFTERM| (implies (imap-cst-matchp cst "\"Apr\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Aug"-LEAFTERM| (implies (imap-cst-matchp cst "\"Aug\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BAD"-LEAFTERM| (implies (imap-cst-matchp cst "\"BAD\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BADCHARSET"-LEAFTERM| (implies (imap-cst-matchp cst "\"BADCHARSET\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BASE64"-LEAFTERM| (implies (imap-cst-matchp cst "\"BASE64\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BCC"-LEAFTERM| (implies (imap-cst-matchp cst "\"BCC\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BEFORE"-LEAFTERM| (implies (imap-cst-matchp cst "\"BEFORE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BINARY"-LEAFTERM| (implies (imap-cst-matchp cst "\"BINARY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BODY"-LEAFTERM| (implies (imap-cst-matchp cst "\"BODY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BODY.PEEK"-LEAFTERM| (implies (imap-cst-matchp cst "\"BODY.PEEK\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"BYE"-LEAFTERM| (implies (imap-cst-matchp cst "\"BYE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CAPABILITY"-LEAFTERM| (implies (imap-cst-matchp cst "\"CAPABILITY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CC"-LEAFTERM| (implies (imap-cst-matchp cst "\"CC\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CHARSET"-LEAFTERM| (implies (imap-cst-matchp cst "\"CHARSET\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CHECK"-LEAFTERM| (implies (imap-cst-matchp cst "\"CHECK\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CLOSE"-LEAFTERM| (implies (imap-cst-matchp cst "\"CLOSE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"COPY"-LEAFTERM| (implies (imap-cst-matchp cst "\"COPY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"CREATE"-LEAFTERM| (implies (imap-cst-matchp cst "\"CREATE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"DELETE"-LEAFTERM| (implies (imap-cst-matchp cst "\"DELETE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"DELETED"-LEAFTERM| (implies (imap-cst-matchp cst "\"DELETED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"DRAFT"-LEAFTERM| (implies (imap-cst-matchp cst "\"DRAFT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Dec"-LEAFTERM| (implies (imap-cst-matchp cst "\"Dec\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"ENVELOPE"-LEAFTERM| (implies (imap-cst-matchp cst "\"ENVELOPE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"EXAMINE"-LEAFTERM| (implies (imap-cst-matchp cst "\"EXAMINE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"EXISTS"-LEAFTERM| (implies (imap-cst-matchp cst "\"EXISTS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"EXPUNGE"-LEAFTERM| (implies (imap-cst-matchp cst "\"EXPUNGE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FAST"-LEAFTERM| (implies (imap-cst-matchp cst "\"FAST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FETCH"-LEAFTERM| (implies (imap-cst-matchp cst "\"FETCH\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FLAGGED"-LEAFTERM| (implies (imap-cst-matchp cst "\"FLAGGED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FLAGS"-LEAFTERM| (implies (imap-cst-matchp cst "\"FLAGS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FROM"-LEAFTERM| (implies (imap-cst-matchp cst "\"FROM\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"FULL"-LEAFTERM| (implies (imap-cst-matchp cst "\"FULL\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Feb"-LEAFTERM| (implies (imap-cst-matchp cst "\"Feb\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"HEADER"-LEAFTERM| (implies (imap-cst-matchp cst "\"HEADER\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"HEADER.FIELDS"-LEAFTERM| (implies (imap-cst-matchp cst "\"HEADER.FIELDS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"IMAGE"-LEAFTERM| (implies (imap-cst-matchp cst "\"IMAGE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"IMAP4rev1"-LEAFTERM| (implies (imap-cst-matchp cst "\"IMAP4rev1\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"INBOX"-LEAFTERM| (implies (imap-cst-matchp cst "\"INBOX\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"INTERNALDATE"-LEAFTERM| (implies (imap-cst-matchp cst "\"INTERNALDATE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Jan"-LEAFTERM| (implies (imap-cst-matchp cst "\"Jan\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Jul"-LEAFTERM| (implies (imap-cst-matchp cst "\"Jul\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Jun"-LEAFTERM| (implies (imap-cst-matchp cst "\"Jun\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"KEYWORD"-LEAFTERM| (implies (imap-cst-matchp cst "\"KEYWORD\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"LARGER"-LEAFTERM| (implies (imap-cst-matchp cst "\"LARGER\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"LIST"-LEAFTERM| (implies (imap-cst-matchp cst "\"LIST\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"LOGIN"-LEAFTERM| (implies (imap-cst-matchp cst "\"LOGIN\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"LOGOUT"-LEAFTERM| (implies (imap-cst-matchp cst "\"LOGOUT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"LSUB"-LEAFTERM| (implies (imap-cst-matchp cst "\"LSUB\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"MESSAGE"-LEAFTERM| (implies (imap-cst-matchp cst "\"MESSAGE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"MESSAGES"-LEAFTERM| (implies (imap-cst-matchp cst "\"MESSAGES\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"MIME"-LEAFTERM| (implies (imap-cst-matchp cst "\"MIME\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Mar"-LEAFTERM| (implies (imap-cst-matchp cst "\"Mar\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"May"-LEAFTERM| (implies (imap-cst-matchp cst "\"May\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"NEW"-LEAFTERM| (implies (imap-cst-matchp cst "\"NEW\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"NIL"-LEAFTERM| (implies (imap-cst-matchp cst "\"NIL\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"NO"-LEAFTERM| (implies (imap-cst-matchp cst "\"NO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"NOOP"-LEAFTERM| (implies (imap-cst-matchp cst "\"NOOP\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"NOT"-LEAFTERM| (implies (imap-cst-matchp cst "\"NOT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Nov"-LEAFTERM| (implies (imap-cst-matchp cst "\"Nov\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"OK"-LEAFTERM| (implies (imap-cst-matchp cst "\"OK\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"OLD"-LEAFTERM| (implies (imap-cst-matchp cst "\"OLD\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"ON"-LEAFTERM| (implies (imap-cst-matchp cst "\"ON\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"OR"-LEAFTERM| (implies (imap-cst-matchp cst "\"OR\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Oct"-LEAFTERM| (implies (imap-cst-matchp cst "\"Oct\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"PARSE"-LEAFTERM| (implies (imap-cst-matchp cst "\"PARSE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"PERMANENTFLAGS"-LEAFTERM| (implies (imap-cst-matchp cst "\"PERMANENTFLAGS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"PREAUTH"-LEAFTERM| (implies (imap-cst-matchp cst "\"PREAUTH\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"QUOTED-PRINTABLE"-LEAFTERM| (implies (imap-cst-matchp cst "\"QUOTED-PRINTABLE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"READ-ONLY"-LEAFTERM| (implies (imap-cst-matchp cst "\"READ-ONLY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"READ-WRITE"-LEAFTERM| (implies (imap-cst-matchp cst "\"READ-WRITE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"RECENT"-LEAFTERM| (implies (imap-cst-matchp cst "\"RECENT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"RENAME"-LEAFTERM| (implies (imap-cst-matchp cst "\"RENAME\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"RFC822"-LEAFTERM| (implies (imap-cst-matchp cst "\"RFC822\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"RFC822.SIZE"-LEAFTERM| (implies (imap-cst-matchp cst "\"RFC822.SIZE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SEARCH"-LEAFTERM| (implies (imap-cst-matchp cst "\"SEARCH\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SEEN"-LEAFTERM| (implies (imap-cst-matchp cst "\"SEEN\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SELECT"-LEAFTERM| (implies (imap-cst-matchp cst "\"SELECT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SENTBEFORE"-LEAFTERM| (implies (imap-cst-matchp cst "\"SENTBEFORE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SENTON"-LEAFTERM| (implies (imap-cst-matchp cst "\"SENTON\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SENTSINCE"-LEAFTERM| (implies (imap-cst-matchp cst "\"SENTSINCE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SINCE"-LEAFTERM| (implies (imap-cst-matchp cst "\"SINCE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SMALLER"-LEAFTERM| (implies (imap-cst-matchp cst "\"SMALLER\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"STARTTLS"-LEAFTERM| (implies (imap-cst-matchp cst "\"STARTTLS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"STATUS"-LEAFTERM| (implies (imap-cst-matchp cst "\"STATUS\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"STORE"-LEAFTERM| (implies (imap-cst-matchp cst "\"STORE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"STRUCTURE"-LEAFTERM| (implies (imap-cst-matchp cst "\"STRUCTURE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SUBJECT"-LEAFTERM| (implies (imap-cst-matchp cst "\"SUBJECT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"SUBSCRIBE"-LEAFTERM| (implies (imap-cst-matchp cst "\"SUBSCRIBE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"Sep"-LEAFTERM| (implies (imap-cst-matchp cst "\"Sep\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"TEXT"-LEAFTERM| (implies (imap-cst-matchp cst "\"TEXT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"TO"-LEAFTERM| (implies (imap-cst-matchp cst "\"TO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"TRYCREATE"-LEAFTERM| (implies (imap-cst-matchp cst "\"TRYCREATE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UID"-LEAFTERM| (implies (imap-cst-matchp cst "\"UID\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UIDNEXT"-LEAFTERM| (implies (imap-cst-matchp cst "\"UIDNEXT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UIDVALIDITY"-LEAFTERM| (implies (imap-cst-matchp cst "\"UIDVALIDITY\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNANSWERED"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNANSWERED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNDELETED"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNDELETED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNDRAFT"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNDRAFT\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNFLAGGED"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNFLAGGED\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNKEYWORD"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNKEYWORD\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNSEEN"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNSEEN\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"UNSUBSCRIBE"-LEAFTERM| (implies (imap-cst-matchp cst "\"UNSUBSCRIBE\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"VIDEO"-LEAFTERM| (implies (imap-cst-matchp cst "\"VIDEO\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"X"-LEAFTERM| (implies (imap-cst-matchp cst "\"X\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"["-LEAFTERM| (implies (imap-cst-matchp cst "\"[\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\*"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\*\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Answered"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Answered\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Deleted"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Deleted\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Draft"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Draft\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Flagged"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Flagged\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Marked"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Marked\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Noinferiors"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Noinferiors\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Noselect"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Noselect\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Recent"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Recent\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Seen"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Seen\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"\\Unmarked"-LEAFTERM| (implies (imap-cst-matchp cst "\"\\Unmarked\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"]"-LEAFTERM| (implies (imap-cst-matchp cst "\"]\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"{"-LEAFTERM| (implies (imap-cst-matchp cst "\"{\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |IMAP-CST-"}"-LEAFTERM| (implies (imap-cst-matchp cst "\"}\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm imap-cst-address-nonleaf (implies (imap-cst-matchp cst "address") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-addr-adl-nonleaf (implies (imap-cst-matchp cst "addr-adl") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-addr-host-nonleaf (implies (imap-cst-matchp cst "addr-host") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-addr-mailbox-nonleaf (implies (imap-cst-matchp cst "addr-mailbox") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-addr-name-nonleaf (implies (imap-cst-matchp cst "addr-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-append-nonleaf (implies (imap-cst-matchp cst "append") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-astring-nonleaf (implies (imap-cst-matchp cst "astring") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-astring-char-nonleaf (implies (imap-cst-matchp cst "astring-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-atom-nonleaf (implies (imap-cst-matchp cst "atom") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-atom-char-nonleaf (implies (imap-cst-matchp cst "atom-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-atom-specials-nonleaf (implies (imap-cst-matchp cst "atom-specials") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-authenticate-nonleaf (implies (imap-cst-matchp cst "authenticate") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-auth-type-nonleaf (implies (imap-cst-matchp cst "auth-type") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-base64-nonleaf (implies (imap-cst-matchp cst "base64") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-base64-char-nonleaf (implies (imap-cst-matchp cst "base64-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-base64-terminal-nonleaf (implies (imap-cst-matchp cst "base64-terminal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-nonleaf (implies (imap-cst-matchp cst "body") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-extension-nonleaf (implies (imap-cst-matchp cst "body-extension") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-ext-1part-nonleaf (implies (imap-cst-matchp cst "body-ext-1part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-ext-mpart-nonleaf (implies (imap-cst-matchp cst "body-ext-mpart") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fields-nonleaf (implies (imap-cst-matchp cst "body-fields") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-desc-nonleaf (implies (imap-cst-matchp cst "body-fld-desc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-dsp-nonleaf (implies (imap-cst-matchp cst "body-fld-dsp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-enc-nonleaf (implies (imap-cst-matchp cst "body-fld-enc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-id-nonleaf (implies (imap-cst-matchp cst "body-fld-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-lang-nonleaf (implies (imap-cst-matchp cst "body-fld-lang") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-loc-nonleaf (implies (imap-cst-matchp cst "body-fld-loc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-lines-nonleaf (implies (imap-cst-matchp cst "body-fld-lines") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-md5-nonleaf (implies (imap-cst-matchp cst "body-fld-md5") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-octets-nonleaf (implies (imap-cst-matchp cst "body-fld-octets") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-fld-param-nonleaf (implies (imap-cst-matchp cst "body-fld-param") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-type-1part-nonleaf (implies (imap-cst-matchp cst "body-type-1part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-type-basic-nonleaf (implies (imap-cst-matchp cst "body-type-basic") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-type-mpart-nonleaf (implies (imap-cst-matchp cst "body-type-mpart") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-type-msg-nonleaf (implies (imap-cst-matchp cst "body-type-msg") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-body-type-text-nonleaf (implies (imap-cst-matchp cst "body-type-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-capability-nonleaf (implies (imap-cst-matchp cst "capability") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-capability-data-nonleaf (implies (imap-cst-matchp cst "capability-data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-char8-nonleaf (implies (imap-cst-matchp cst "char8") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-command-nonleaf (implies (imap-cst-matchp cst "command") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-command-any-nonleaf (implies (imap-cst-matchp cst "command-any") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-command-auth-nonleaf (implies (imap-cst-matchp cst "command-auth") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-command-nonauth-nonleaf (implies (imap-cst-matchp cst "command-nonauth") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-command-select-nonleaf (implies (imap-cst-matchp cst "command-select") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-continue-req-nonleaf (implies (imap-cst-matchp cst "continue-req") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-copy-nonleaf (implies (imap-cst-matchp cst "copy") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-create-nonleaf (implies (imap-cst-matchp cst "create") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-nonleaf (implies (imap-cst-matchp cst "date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-day-nonleaf (implies (imap-cst-matchp cst "date-day") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-day-fixed-nonleaf (implies (imap-cst-matchp cst "date-day-fixed") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-month-nonleaf (implies (imap-cst-matchp cst "date-month") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-text-nonleaf (implies (imap-cst-matchp cst "date-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-year-nonleaf (implies (imap-cst-matchp cst "date-year") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-date-time-nonleaf (implies (imap-cst-matchp cst "date-time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-delete-nonleaf (implies (imap-cst-matchp cst "delete") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-digit-nz-nonleaf (implies (imap-cst-matchp cst "digit-nz") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-envelope-nonleaf (implies (imap-cst-matchp cst "envelope") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-bcc-nonleaf (implies (imap-cst-matchp cst "env-bcc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-cc-nonleaf (implies (imap-cst-matchp cst "env-cc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-date-nonleaf (implies (imap-cst-matchp cst "env-date") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-from-nonleaf (implies (imap-cst-matchp cst "env-from") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-in-reply-to-nonleaf (implies (imap-cst-matchp cst "env-in-reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-message-id-nonleaf (implies (imap-cst-matchp cst "env-message-id") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-reply-to-nonleaf (implies (imap-cst-matchp cst "env-reply-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-sender-nonleaf (implies (imap-cst-matchp cst "env-sender") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-subject-nonleaf (implies (imap-cst-matchp cst "env-subject") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-env-to-nonleaf (implies (imap-cst-matchp cst "env-to") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-examine-nonleaf (implies (imap-cst-matchp cst "examine") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-fetch-nonleaf (implies (imap-cst-matchp cst "fetch") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-fetch-att-nonleaf (implies (imap-cst-matchp cst "fetch-att") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-nonleaf (implies (imap-cst-matchp cst "flag") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-extension-nonleaf (implies (imap-cst-matchp cst "flag-extension") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-fetch-nonleaf (implies (imap-cst-matchp cst "flag-fetch") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-keyword-nonleaf (implies (imap-cst-matchp cst "flag-keyword") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-list-nonleaf (implies (imap-cst-matchp cst "flag-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-flag-perm-nonleaf (implies (imap-cst-matchp cst "flag-perm") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-greeting-nonleaf (implies (imap-cst-matchp cst "greeting") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-header-fld-name-nonleaf (implies (imap-cst-matchp cst "header-fld-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-header-list-nonleaf (implies (imap-cst-matchp cst "header-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-list-nonleaf (implies (imap-cst-matchp cst "list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-list-mailbox-nonleaf (implies (imap-cst-matchp cst "list-mailbox") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-list-char-nonleaf (implies (imap-cst-matchp cst "list-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-list-wildcards-nonleaf (implies (imap-cst-matchp cst "list-wildcards") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-literal-nonleaf (implies (imap-cst-matchp cst "literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-login-nonleaf (implies (imap-cst-matchp cst "login") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-lsub-nonleaf (implies (imap-cst-matchp cst "lsub") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mailbox-nonleaf (implies (imap-cst-matchp cst "mailbox") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mailbox-data-nonleaf (implies (imap-cst-matchp cst "mailbox-data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mailbox-list-nonleaf (implies (imap-cst-matchp cst "mailbox-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mbx-list-flags-nonleaf (implies (imap-cst-matchp cst "mbx-list-flags") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mbx-list-oflag-nonleaf (implies (imap-cst-matchp cst "mbx-list-oflag") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-mbx-list-sflag-nonleaf (implies (imap-cst-matchp cst "mbx-list-sflag") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-media-basic-nonleaf (implies (imap-cst-matchp cst "media-basic") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-media-message-nonleaf (implies (imap-cst-matchp cst "media-message") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-media-subtype-nonleaf (implies (imap-cst-matchp cst "media-subtype") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-media-text-nonleaf (implies (imap-cst-matchp cst "media-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-message-data-nonleaf (implies (imap-cst-matchp cst "message-data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-msg-att-nonleaf (implies (imap-cst-matchp cst "msg-att") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-msg-att-dynamic-nonleaf (implies (imap-cst-matchp cst "msg-att-dynamic") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-msg-att-static-nonleaf (implies (imap-cst-matchp cst "msg-att-static") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-nil-nonleaf (implies (imap-cst-matchp cst "nil") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-nstring-nonleaf (implies (imap-cst-matchp cst "nstring") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-number-nonleaf (implies (imap-cst-matchp cst "number") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-nz-number-nonleaf (implies (imap-cst-matchp cst "nz-number") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-password-nonleaf (implies (imap-cst-matchp cst "password") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-quoted-nonleaf (implies (imap-cst-matchp cst "quoted") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-quoted-char-nonleaf (implies (imap-cst-matchp cst "quoted-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-quoted-specials-nonleaf (implies (imap-cst-matchp cst "quoted-specials") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-rename-nonleaf (implies (imap-cst-matchp cst "rename") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-response-nonleaf (implies (imap-cst-matchp cst "response") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-response-data-nonleaf (implies (imap-cst-matchp cst "response-data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-response-done-nonleaf (implies (imap-cst-matchp cst "response-done") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-response-fatal-nonleaf (implies (imap-cst-matchp cst "response-fatal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-response-tagged-nonleaf (implies (imap-cst-matchp cst "response-tagged") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-cond-auth-nonleaf (implies (imap-cst-matchp cst "resp-cond-auth") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-cond-bye-nonleaf (implies (imap-cst-matchp cst "resp-cond-bye") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-cond-state-nonleaf (implies (imap-cst-matchp cst "resp-cond-state") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-specials-nonleaf (implies (imap-cst-matchp cst "resp-specials") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-text-nonleaf (implies (imap-cst-matchp cst "resp-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-resp-text-code-nonleaf (implies (imap-cst-matchp cst "resp-text-code") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-search-nonleaf (implies (imap-cst-matchp cst "search") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-search-key-nonleaf (implies (imap-cst-matchp cst "search-key") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-section-nonleaf (implies (imap-cst-matchp cst "section") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-section-msgtext-nonleaf (implies (imap-cst-matchp cst "section-msgtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-section-part-nonleaf (implies (imap-cst-matchp cst "section-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-section-spec-nonleaf (implies (imap-cst-matchp cst "section-spec") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-section-text-nonleaf (implies (imap-cst-matchp cst "section-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-select-nonleaf (implies (imap-cst-matchp cst "select") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-seq-number-nonleaf (implies (imap-cst-matchp cst "seq-number") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-seq-range-nonleaf (implies (imap-cst-matchp cst "seq-range") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-sequence-set-nonleaf (implies (imap-cst-matchp cst "sequence-set") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-status-nonleaf (implies (imap-cst-matchp cst "status") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-status-att-nonleaf (implies (imap-cst-matchp cst "status-att") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-status-att-list-nonleaf (implies (imap-cst-matchp cst "status-att-list") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-store-nonleaf (implies (imap-cst-matchp cst "store") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-store-att-flags-nonleaf (implies (imap-cst-matchp cst "store-att-flags") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-string-nonleaf (implies (imap-cst-matchp cst "string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-subscribe-nonleaf (implies (imap-cst-matchp cst "subscribe") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-tag-nonleaf (implies (imap-cst-matchp cst "tag") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-text-nonleaf (implies (imap-cst-matchp cst "text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-text-char-nonleaf (implies (imap-cst-matchp cst "text-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-time-nonleaf (implies (imap-cst-matchp cst "time") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-uid-nonleaf (implies (imap-cst-matchp cst "uid") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-uniqueid-nonleaf (implies (imap-cst-matchp cst "uniqueid") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-unsubscribe-nonleaf (implies (imap-cst-matchp cst "unsubscribe") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-userid-nonleaf (implies (imap-cst-matchp cst "userid") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-x-command-nonleaf (implies (imap-cst-matchp cst "x-command") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-zone-nonleaf (implies (imap-cst-matchp cst "zone") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-alpha-nonleaf (implies (imap-cst-matchp cst "alpha") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-crlf-nonleaf (implies (imap-cst-matchp cst "crlf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-cr-nonleaf (implies (imap-cst-matchp cst "cr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-ctl-nonleaf (implies (imap-cst-matchp cst "ctl") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-digit-nonleaf (implies (imap-cst-matchp cst "digit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-dquote-nonleaf (implies (imap-cst-matchp cst "dquote") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-lf-nonleaf (implies (imap-cst-matchp cst "lf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-sp-nonleaf (implies (imap-cst-matchp cst "sp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm imap-cst-address-rulename (implies (imap-cst-matchp cst "address") (equal (tree-nonleaf->rulename? cst) (rulename "address"))))
Theorem:
(defthm imap-cst-addr-adl-rulename (implies (imap-cst-matchp cst "addr-adl") (equal (tree-nonleaf->rulename? cst) (rulename "addr-adl"))))
Theorem:
(defthm imap-cst-addr-host-rulename (implies (imap-cst-matchp cst "addr-host") (equal (tree-nonleaf->rulename? cst) (rulename "addr-host"))))
Theorem:
(defthm imap-cst-addr-mailbox-rulename (implies (imap-cst-matchp cst "addr-mailbox") (equal (tree-nonleaf->rulename? cst) (rulename "addr-mailbox"))))
Theorem:
(defthm imap-cst-addr-name-rulename (implies (imap-cst-matchp cst "addr-name") (equal (tree-nonleaf->rulename? cst) (rulename "addr-name"))))
Theorem:
(defthm imap-cst-append-rulename (implies (imap-cst-matchp cst "append") (equal (tree-nonleaf->rulename? cst) (rulename "append"))))
Theorem:
(defthm imap-cst-astring-rulename (implies (imap-cst-matchp cst "astring") (equal (tree-nonleaf->rulename? cst) (rulename "astring"))))
Theorem:
(defthm imap-cst-astring-char-rulename (implies (imap-cst-matchp cst "astring-char") (equal (tree-nonleaf->rulename? cst) (rulename "astring-char"))))
Theorem:
(defthm imap-cst-atom-rulename (implies (imap-cst-matchp cst "atom") (equal (tree-nonleaf->rulename? cst) (rulename "atom"))))
Theorem:
(defthm imap-cst-atom-char-rulename (implies (imap-cst-matchp cst "atom-char") (equal (tree-nonleaf->rulename? cst) (rulename "atom-char"))))
Theorem:
(defthm imap-cst-atom-specials-rulename (implies (imap-cst-matchp cst "atom-specials") (equal (tree-nonleaf->rulename? cst) (rulename "atom-specials"))))
Theorem:
(defthm imap-cst-authenticate-rulename (implies (imap-cst-matchp cst "authenticate") (equal (tree-nonleaf->rulename? cst) (rulename "authenticate"))))
Theorem:
(defthm imap-cst-auth-type-rulename (implies (imap-cst-matchp cst "auth-type") (equal (tree-nonleaf->rulename? cst) (rulename "auth-type"))))
Theorem:
(defthm imap-cst-base64-rulename (implies (imap-cst-matchp cst "base64") (equal (tree-nonleaf->rulename? cst) (rulename "base64"))))
Theorem:
(defthm imap-cst-base64-char-rulename (implies (imap-cst-matchp cst "base64-char") (equal (tree-nonleaf->rulename? cst) (rulename "base64-char"))))
Theorem:
(defthm imap-cst-base64-terminal-rulename (implies (imap-cst-matchp cst "base64-terminal") (equal (tree-nonleaf->rulename? cst) (rulename "base64-terminal"))))
Theorem:
(defthm imap-cst-body-rulename (implies (imap-cst-matchp cst "body") (equal (tree-nonleaf->rulename? cst) (rulename "body"))))
Theorem:
(defthm imap-cst-body-extension-rulename (implies (imap-cst-matchp cst "body-extension") (equal (tree-nonleaf->rulename? cst) (rulename "body-extension"))))
Theorem:
(defthm imap-cst-body-ext-1part-rulename (implies (imap-cst-matchp cst "body-ext-1part") (equal (tree-nonleaf->rulename? cst) (rulename "body-ext-1part"))))
Theorem:
(defthm imap-cst-body-ext-mpart-rulename (implies (imap-cst-matchp cst "body-ext-mpart") (equal (tree-nonleaf->rulename? cst) (rulename "body-ext-mpart"))))
Theorem:
(defthm imap-cst-body-fields-rulename (implies (imap-cst-matchp cst "body-fields") (equal (tree-nonleaf->rulename? cst) (rulename "body-fields"))))
Theorem:
(defthm imap-cst-body-fld-desc-rulename (implies (imap-cst-matchp cst "body-fld-desc") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-desc"))))
Theorem:
(defthm imap-cst-body-fld-dsp-rulename (implies (imap-cst-matchp cst "body-fld-dsp") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-dsp"))))
Theorem:
(defthm imap-cst-body-fld-enc-rulename (implies (imap-cst-matchp cst "body-fld-enc") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-enc"))))
Theorem:
(defthm imap-cst-body-fld-id-rulename (implies (imap-cst-matchp cst "body-fld-id") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-id"))))
Theorem:
(defthm imap-cst-body-fld-lang-rulename (implies (imap-cst-matchp cst "body-fld-lang") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-lang"))))
Theorem:
(defthm imap-cst-body-fld-loc-rulename (implies (imap-cst-matchp cst "body-fld-loc") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-loc"))))
Theorem:
(defthm imap-cst-body-fld-lines-rulename (implies (imap-cst-matchp cst "body-fld-lines") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-lines"))))
Theorem:
(defthm imap-cst-body-fld-md5-rulename (implies (imap-cst-matchp cst "body-fld-md5") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-md5"))))
Theorem:
(defthm imap-cst-body-fld-octets-rulename (implies (imap-cst-matchp cst "body-fld-octets") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-octets"))))
Theorem:
(defthm imap-cst-body-fld-param-rulename (implies (imap-cst-matchp cst "body-fld-param") (equal (tree-nonleaf->rulename? cst) (rulename "body-fld-param"))))
Theorem:
(defthm imap-cst-body-type-1part-rulename (implies (imap-cst-matchp cst "body-type-1part") (equal (tree-nonleaf->rulename? cst) (rulename "body-type-1part"))))
Theorem:
(defthm imap-cst-body-type-basic-rulename (implies (imap-cst-matchp cst "body-type-basic") (equal (tree-nonleaf->rulename? cst) (rulename "body-type-basic"))))
Theorem:
(defthm imap-cst-body-type-mpart-rulename (implies (imap-cst-matchp cst "body-type-mpart") (equal (tree-nonleaf->rulename? cst) (rulename "body-type-mpart"))))
Theorem:
(defthm imap-cst-body-type-msg-rulename (implies (imap-cst-matchp cst "body-type-msg") (equal (tree-nonleaf->rulename? cst) (rulename "body-type-msg"))))
Theorem:
(defthm imap-cst-body-type-text-rulename (implies (imap-cst-matchp cst "body-type-text") (equal (tree-nonleaf->rulename? cst) (rulename "body-type-text"))))
Theorem:
(defthm imap-cst-capability-rulename (implies (imap-cst-matchp cst "capability") (equal (tree-nonleaf->rulename? cst) (rulename "capability"))))
Theorem:
(defthm imap-cst-capability-data-rulename (implies (imap-cst-matchp cst "capability-data") (equal (tree-nonleaf->rulename? cst) (rulename "capability-data"))))
Theorem:
(defthm imap-cst-char8-rulename (implies (imap-cst-matchp cst "char8") (equal (tree-nonleaf->rulename? cst) (rulename "char8"))))
Theorem:
(defthm imap-cst-command-rulename (implies (imap-cst-matchp cst "command") (equal (tree-nonleaf->rulename? cst) (rulename "command"))))
Theorem:
(defthm imap-cst-command-any-rulename (implies (imap-cst-matchp cst "command-any") (equal (tree-nonleaf->rulename? cst) (rulename "command-any"))))
Theorem:
(defthm imap-cst-command-auth-rulename (implies (imap-cst-matchp cst "command-auth") (equal (tree-nonleaf->rulename? cst) (rulename "command-auth"))))
Theorem:
(defthm imap-cst-command-nonauth-rulename (implies (imap-cst-matchp cst "command-nonauth") (equal (tree-nonleaf->rulename? cst) (rulename "command-nonauth"))))
Theorem:
(defthm imap-cst-command-select-rulename (implies (imap-cst-matchp cst "command-select") (equal (tree-nonleaf->rulename? cst) (rulename "command-select"))))
Theorem:
(defthm imap-cst-continue-req-rulename (implies (imap-cst-matchp cst "continue-req") (equal (tree-nonleaf->rulename? cst) (rulename "continue-req"))))
Theorem:
(defthm imap-cst-copy-rulename (implies (imap-cst-matchp cst "copy") (equal (tree-nonleaf->rulename? cst) (rulename "copy"))))
Theorem:
(defthm imap-cst-create-rulename (implies (imap-cst-matchp cst "create") (equal (tree-nonleaf->rulename? cst) (rulename "create"))))
Theorem:
(defthm imap-cst-date-rulename (implies (imap-cst-matchp cst "date") (equal (tree-nonleaf->rulename? cst) (rulename "date"))))
Theorem:
(defthm imap-cst-date-day-rulename (implies (imap-cst-matchp cst "date-day") (equal (tree-nonleaf->rulename? cst) (rulename "date-day"))))
Theorem:
(defthm imap-cst-date-day-fixed-rulename (implies (imap-cst-matchp cst "date-day-fixed") (equal (tree-nonleaf->rulename? cst) (rulename "date-day-fixed"))))
Theorem:
(defthm imap-cst-date-month-rulename (implies (imap-cst-matchp cst "date-month") (equal (tree-nonleaf->rulename? cst) (rulename "date-month"))))
Theorem:
(defthm imap-cst-date-text-rulename (implies (imap-cst-matchp cst "date-text") (equal (tree-nonleaf->rulename? cst) (rulename "date-text"))))
Theorem:
(defthm imap-cst-date-year-rulename (implies (imap-cst-matchp cst "date-year") (equal (tree-nonleaf->rulename? cst) (rulename "date-year"))))
Theorem:
(defthm imap-cst-date-time-rulename (implies (imap-cst-matchp cst "date-time") (equal (tree-nonleaf->rulename? cst) (rulename "date-time"))))
Theorem:
(defthm imap-cst-delete-rulename (implies (imap-cst-matchp cst "delete") (equal (tree-nonleaf->rulename? cst) (rulename "delete"))))
Theorem:
(defthm imap-cst-digit-nz-rulename (implies (imap-cst-matchp cst "digit-nz") (equal (tree-nonleaf->rulename? cst) (rulename "digit-nz"))))
Theorem:
(defthm imap-cst-envelope-rulename (implies (imap-cst-matchp cst "envelope") (equal (tree-nonleaf->rulename? cst) (rulename "envelope"))))
Theorem:
(defthm imap-cst-env-bcc-rulename (implies (imap-cst-matchp cst "env-bcc") (equal (tree-nonleaf->rulename? cst) (rulename "env-bcc"))))
Theorem:
(defthm imap-cst-env-cc-rulename (implies (imap-cst-matchp cst "env-cc") (equal (tree-nonleaf->rulename? cst) (rulename "env-cc"))))
Theorem:
(defthm imap-cst-env-date-rulename (implies (imap-cst-matchp cst "env-date") (equal (tree-nonleaf->rulename? cst) (rulename "env-date"))))
Theorem:
(defthm imap-cst-env-from-rulename (implies (imap-cst-matchp cst "env-from") (equal (tree-nonleaf->rulename? cst) (rulename "env-from"))))
Theorem:
(defthm imap-cst-env-in-reply-to-rulename (implies (imap-cst-matchp cst "env-in-reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "env-in-reply-to"))))
Theorem:
(defthm imap-cst-env-message-id-rulename (implies (imap-cst-matchp cst "env-message-id") (equal (tree-nonleaf->rulename? cst) (rulename "env-message-id"))))
Theorem:
(defthm imap-cst-env-reply-to-rulename (implies (imap-cst-matchp cst "env-reply-to") (equal (tree-nonleaf->rulename? cst) (rulename "env-reply-to"))))
Theorem:
(defthm imap-cst-env-sender-rulename (implies (imap-cst-matchp cst "env-sender") (equal (tree-nonleaf->rulename? cst) (rulename "env-sender"))))
Theorem:
(defthm imap-cst-env-subject-rulename (implies (imap-cst-matchp cst "env-subject") (equal (tree-nonleaf->rulename? cst) (rulename "env-subject"))))
Theorem:
(defthm imap-cst-env-to-rulename (implies (imap-cst-matchp cst "env-to") (equal (tree-nonleaf->rulename? cst) (rulename "env-to"))))
Theorem:
(defthm imap-cst-examine-rulename (implies (imap-cst-matchp cst "examine") (equal (tree-nonleaf->rulename? cst) (rulename "examine"))))
Theorem:
(defthm imap-cst-fetch-rulename (implies (imap-cst-matchp cst "fetch") (equal (tree-nonleaf->rulename? cst) (rulename "fetch"))))
Theorem:
(defthm imap-cst-fetch-att-rulename (implies (imap-cst-matchp cst "fetch-att") (equal (tree-nonleaf->rulename? cst) (rulename "fetch-att"))))
Theorem:
(defthm imap-cst-flag-rulename (implies (imap-cst-matchp cst "flag") (equal (tree-nonleaf->rulename? cst) (rulename "flag"))))
Theorem:
(defthm imap-cst-flag-extension-rulename (implies (imap-cst-matchp cst "flag-extension") (equal (tree-nonleaf->rulename? cst) (rulename "flag-extension"))))
Theorem:
(defthm imap-cst-flag-fetch-rulename (implies (imap-cst-matchp cst "flag-fetch") (equal (tree-nonleaf->rulename? cst) (rulename "flag-fetch"))))
Theorem:
(defthm imap-cst-flag-keyword-rulename (implies (imap-cst-matchp cst "flag-keyword") (equal (tree-nonleaf->rulename? cst) (rulename "flag-keyword"))))
Theorem:
(defthm imap-cst-flag-list-rulename (implies (imap-cst-matchp cst "flag-list") (equal (tree-nonleaf->rulename? cst) (rulename "flag-list"))))
Theorem:
(defthm imap-cst-flag-perm-rulename (implies (imap-cst-matchp cst "flag-perm") (equal (tree-nonleaf->rulename? cst) (rulename "flag-perm"))))
Theorem:
(defthm imap-cst-greeting-rulename (implies (imap-cst-matchp cst "greeting") (equal (tree-nonleaf->rulename? cst) (rulename "greeting"))))
Theorem:
(defthm imap-cst-header-fld-name-rulename (implies (imap-cst-matchp cst "header-fld-name") (equal (tree-nonleaf->rulename? cst) (rulename "header-fld-name"))))
Theorem:
(defthm imap-cst-header-list-rulename (implies (imap-cst-matchp cst "header-list") (equal (tree-nonleaf->rulename? cst) (rulename "header-list"))))
Theorem:
(defthm imap-cst-list-rulename (implies (imap-cst-matchp cst "list") (equal (tree-nonleaf->rulename? cst) (rulename "list"))))
Theorem:
(defthm imap-cst-list-mailbox-rulename (implies (imap-cst-matchp cst "list-mailbox") (equal (tree-nonleaf->rulename? cst) (rulename "list-mailbox"))))
Theorem:
(defthm imap-cst-list-char-rulename (implies (imap-cst-matchp cst "list-char") (equal (tree-nonleaf->rulename? cst) (rulename "list-char"))))
Theorem:
(defthm imap-cst-list-wildcards-rulename (implies (imap-cst-matchp cst "list-wildcards") (equal (tree-nonleaf->rulename? cst) (rulename "list-wildcards"))))
Theorem:
(defthm imap-cst-literal-rulename (implies (imap-cst-matchp cst "literal") (equal (tree-nonleaf->rulename? cst) (rulename "literal"))))
Theorem:
(defthm imap-cst-login-rulename (implies (imap-cst-matchp cst "login") (equal (tree-nonleaf->rulename? cst) (rulename "login"))))
Theorem:
(defthm imap-cst-lsub-rulename (implies (imap-cst-matchp cst "lsub") (equal (tree-nonleaf->rulename? cst) (rulename "lsub"))))
Theorem:
(defthm imap-cst-mailbox-rulename (implies (imap-cst-matchp cst "mailbox") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox"))))
Theorem:
(defthm imap-cst-mailbox-data-rulename (implies (imap-cst-matchp cst "mailbox-data") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox-data"))))
Theorem:
(defthm imap-cst-mailbox-list-rulename (implies (imap-cst-matchp cst "mailbox-list") (equal (tree-nonleaf->rulename? cst) (rulename "mailbox-list"))))
Theorem:
(defthm imap-cst-mbx-list-flags-rulename (implies (imap-cst-matchp cst "mbx-list-flags") (equal (tree-nonleaf->rulename? cst) (rulename "mbx-list-flags"))))
Theorem:
(defthm imap-cst-mbx-list-oflag-rulename (implies (imap-cst-matchp cst "mbx-list-oflag") (equal (tree-nonleaf->rulename? cst) (rulename "mbx-list-oflag"))))
Theorem:
(defthm imap-cst-mbx-list-sflag-rulename (implies (imap-cst-matchp cst "mbx-list-sflag") (equal (tree-nonleaf->rulename? cst) (rulename "mbx-list-sflag"))))
Theorem:
(defthm imap-cst-media-basic-rulename (implies (imap-cst-matchp cst "media-basic") (equal (tree-nonleaf->rulename? cst) (rulename "media-basic"))))
Theorem:
(defthm imap-cst-media-message-rulename (implies (imap-cst-matchp cst "media-message") (equal (tree-nonleaf->rulename? cst) (rulename "media-message"))))
Theorem:
(defthm imap-cst-media-subtype-rulename (implies (imap-cst-matchp cst "media-subtype") (equal (tree-nonleaf->rulename? cst) (rulename "media-subtype"))))
Theorem:
(defthm imap-cst-media-text-rulename (implies (imap-cst-matchp cst "media-text") (equal (tree-nonleaf->rulename? cst) (rulename "media-text"))))
Theorem:
(defthm imap-cst-message-data-rulename (implies (imap-cst-matchp cst "message-data") (equal (tree-nonleaf->rulename? cst) (rulename "message-data"))))
Theorem:
(defthm imap-cst-msg-att-rulename (implies (imap-cst-matchp cst "msg-att") (equal (tree-nonleaf->rulename? cst) (rulename "msg-att"))))
Theorem:
(defthm imap-cst-msg-att-dynamic-rulename (implies (imap-cst-matchp cst "msg-att-dynamic") (equal (tree-nonleaf->rulename? cst) (rulename "msg-att-dynamic"))))
Theorem:
(defthm imap-cst-msg-att-static-rulename (implies (imap-cst-matchp cst "msg-att-static") (equal (tree-nonleaf->rulename? cst) (rulename "msg-att-static"))))
Theorem:
(defthm imap-cst-nil-rulename (implies (imap-cst-matchp cst "nil") (equal (tree-nonleaf->rulename? cst) (rulename "nil"))))
Theorem:
(defthm imap-cst-nstring-rulename (implies (imap-cst-matchp cst "nstring") (equal (tree-nonleaf->rulename? cst) (rulename "nstring"))))
Theorem:
(defthm imap-cst-number-rulename (implies (imap-cst-matchp cst "number") (equal (tree-nonleaf->rulename? cst) (rulename "number"))))
Theorem:
(defthm imap-cst-nz-number-rulename (implies (imap-cst-matchp cst "nz-number") (equal (tree-nonleaf->rulename? cst) (rulename "nz-number"))))
Theorem:
(defthm imap-cst-password-rulename (implies (imap-cst-matchp cst "password") (equal (tree-nonleaf->rulename? cst) (rulename "password"))))
Theorem:
(defthm imap-cst-quoted-rulename (implies (imap-cst-matchp cst "quoted") (equal (tree-nonleaf->rulename? cst) (rulename "quoted"))))
Theorem:
(defthm imap-cst-quoted-char-rulename (implies (imap-cst-matchp cst "quoted-char") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-char"))))
Theorem:
(defthm imap-cst-quoted-specials-rulename (implies (imap-cst-matchp cst "quoted-specials") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-specials"))))
Theorem:
(defthm imap-cst-rename-rulename (implies (imap-cst-matchp cst "rename") (equal (tree-nonleaf->rulename? cst) (rulename "rename"))))
Theorem:
(defthm imap-cst-response-rulename (implies (imap-cst-matchp cst "response") (equal (tree-nonleaf->rulename? cst) (rulename "response"))))
Theorem:
(defthm imap-cst-response-data-rulename (implies (imap-cst-matchp cst "response-data") (equal (tree-nonleaf->rulename? cst) (rulename "response-data"))))
Theorem:
(defthm imap-cst-response-done-rulename (implies (imap-cst-matchp cst "response-done") (equal (tree-nonleaf->rulename? cst) (rulename "response-done"))))
Theorem:
(defthm imap-cst-response-fatal-rulename (implies (imap-cst-matchp cst "response-fatal") (equal (tree-nonleaf->rulename? cst) (rulename "response-fatal"))))
Theorem:
(defthm imap-cst-response-tagged-rulename (implies (imap-cst-matchp cst "response-tagged") (equal (tree-nonleaf->rulename? cst) (rulename "response-tagged"))))
Theorem:
(defthm imap-cst-resp-cond-auth-rulename (implies (imap-cst-matchp cst "resp-cond-auth") (equal (tree-nonleaf->rulename? cst) (rulename "resp-cond-auth"))))
Theorem:
(defthm imap-cst-resp-cond-bye-rulename (implies (imap-cst-matchp cst "resp-cond-bye") (equal (tree-nonleaf->rulename? cst) (rulename "resp-cond-bye"))))
Theorem:
(defthm imap-cst-resp-cond-state-rulename (implies (imap-cst-matchp cst "resp-cond-state") (equal (tree-nonleaf->rulename? cst) (rulename "resp-cond-state"))))
Theorem:
(defthm imap-cst-resp-specials-rulename (implies (imap-cst-matchp cst "resp-specials") (equal (tree-nonleaf->rulename? cst) (rulename "resp-specials"))))
Theorem:
(defthm imap-cst-resp-text-rulename (implies (imap-cst-matchp cst "resp-text") (equal (tree-nonleaf->rulename? cst) (rulename "resp-text"))))
Theorem:
(defthm imap-cst-resp-text-code-rulename (implies (imap-cst-matchp cst "resp-text-code") (equal (tree-nonleaf->rulename? cst) (rulename "resp-text-code"))))
Theorem:
(defthm imap-cst-search-rulename (implies (imap-cst-matchp cst "search") (equal (tree-nonleaf->rulename? cst) (rulename "search"))))
Theorem:
(defthm imap-cst-search-key-rulename (implies (imap-cst-matchp cst "search-key") (equal (tree-nonleaf->rulename? cst) (rulename "search-key"))))
Theorem:
(defthm imap-cst-section-rulename (implies (imap-cst-matchp cst "section") (equal (tree-nonleaf->rulename? cst) (rulename "section"))))
Theorem:
(defthm imap-cst-section-msgtext-rulename (implies (imap-cst-matchp cst "section-msgtext") (equal (tree-nonleaf->rulename? cst) (rulename "section-msgtext"))))
Theorem:
(defthm imap-cst-section-part-rulename (implies (imap-cst-matchp cst "section-part") (equal (tree-nonleaf->rulename? cst) (rulename "section-part"))))
Theorem:
(defthm imap-cst-section-spec-rulename (implies (imap-cst-matchp cst "section-spec") (equal (tree-nonleaf->rulename? cst) (rulename "section-spec"))))
Theorem:
(defthm imap-cst-section-text-rulename (implies (imap-cst-matchp cst "section-text") (equal (tree-nonleaf->rulename? cst) (rulename "section-text"))))
Theorem:
(defthm imap-cst-select-rulename (implies (imap-cst-matchp cst "select") (equal (tree-nonleaf->rulename? cst) (rulename "select"))))
Theorem:
(defthm imap-cst-seq-number-rulename (implies (imap-cst-matchp cst "seq-number") (equal (tree-nonleaf->rulename? cst) (rulename "seq-number"))))
Theorem:
(defthm imap-cst-seq-range-rulename (implies (imap-cst-matchp cst "seq-range") (equal (tree-nonleaf->rulename? cst) (rulename "seq-range"))))
Theorem:
(defthm imap-cst-sequence-set-rulename (implies (imap-cst-matchp cst "sequence-set") (equal (tree-nonleaf->rulename? cst) (rulename "sequence-set"))))
Theorem:
(defthm imap-cst-status-rulename (implies (imap-cst-matchp cst "status") (equal (tree-nonleaf->rulename? cst) (rulename "status"))))
Theorem:
(defthm imap-cst-status-att-rulename (implies (imap-cst-matchp cst "status-att") (equal (tree-nonleaf->rulename? cst) (rulename "status-att"))))
Theorem:
(defthm imap-cst-status-att-list-rulename (implies (imap-cst-matchp cst "status-att-list") (equal (tree-nonleaf->rulename? cst) (rulename "status-att-list"))))
Theorem:
(defthm imap-cst-store-rulename (implies (imap-cst-matchp cst "store") (equal (tree-nonleaf->rulename? cst) (rulename "store"))))
Theorem:
(defthm imap-cst-store-att-flags-rulename (implies (imap-cst-matchp cst "store-att-flags") (equal (tree-nonleaf->rulename? cst) (rulename "store-att-flags"))))
Theorem:
(defthm imap-cst-string-rulename (implies (imap-cst-matchp cst "string") (equal (tree-nonleaf->rulename? cst) (rulename "string"))))
Theorem:
(defthm imap-cst-subscribe-rulename (implies (imap-cst-matchp cst "subscribe") (equal (tree-nonleaf->rulename? cst) (rulename "subscribe"))))
Theorem:
(defthm imap-cst-tag-rulename (implies (imap-cst-matchp cst "tag") (equal (tree-nonleaf->rulename? cst) (rulename "tag"))))
Theorem:
(defthm imap-cst-text-rulename (implies (imap-cst-matchp cst "text") (equal (tree-nonleaf->rulename? cst) (rulename "text"))))
Theorem:
(defthm imap-cst-text-char-rulename (implies (imap-cst-matchp cst "text-char") (equal (tree-nonleaf->rulename? cst) (rulename "text-char"))))
Theorem:
(defthm imap-cst-time-rulename (implies (imap-cst-matchp cst "time") (equal (tree-nonleaf->rulename? cst) (rulename "time"))))
Theorem:
(defthm imap-cst-uid-rulename (implies (imap-cst-matchp cst "uid") (equal (tree-nonleaf->rulename? cst) (rulename "uid"))))
Theorem:
(defthm imap-cst-uniqueid-rulename (implies (imap-cst-matchp cst "uniqueid") (equal (tree-nonleaf->rulename? cst) (rulename "uniqueid"))))
Theorem:
(defthm imap-cst-unsubscribe-rulename (implies (imap-cst-matchp cst "unsubscribe") (equal (tree-nonleaf->rulename? cst) (rulename "unsubscribe"))))
Theorem:
(defthm imap-cst-userid-rulename (implies (imap-cst-matchp cst "userid") (equal (tree-nonleaf->rulename? cst) (rulename "userid"))))
Theorem:
(defthm imap-cst-x-command-rulename (implies (imap-cst-matchp cst "x-command") (equal (tree-nonleaf->rulename? cst) (rulename "x-command"))))
Theorem:
(defthm imap-cst-zone-rulename (implies (imap-cst-matchp cst "zone") (equal (tree-nonleaf->rulename? cst) (rulename "zone"))))
Theorem:
(defthm imap-cst-alpha-rulename (implies (imap-cst-matchp cst "alpha") (equal (tree-nonleaf->rulename? cst) (rulename "alpha"))))
Theorem:
(defthm imap-cst-crlf-rulename (implies (imap-cst-matchp cst "crlf") (equal (tree-nonleaf->rulename? cst) (rulename "crlf"))))
Theorem:
(defthm imap-cst-cr-rulename (implies (imap-cst-matchp cst "cr") (equal (tree-nonleaf->rulename? cst) (rulename "cr"))))
Theorem:
(defthm imap-cst-ctl-rulename (implies (imap-cst-matchp cst "ctl") (equal (tree-nonleaf->rulename? cst) (rulename "ctl"))))
Theorem:
(defthm imap-cst-digit-rulename (implies (imap-cst-matchp cst "digit") (equal (tree-nonleaf->rulename? cst) (rulename "digit"))))
Theorem:
(defthm imap-cst-dquote-rulename (implies (imap-cst-matchp cst "dquote") (equal (tree-nonleaf->rulename? cst) (rulename "dquote"))))
Theorem:
(defthm imap-cst-lf-rulename (implies (imap-cst-matchp cst "lf") (equal (tree-nonleaf->rulename? cst) (rulename "lf"))))
Theorem:
(defthm imap-cst-sp-rulename (implies (imap-cst-matchp cst "sp") (equal (tree-nonleaf->rulename? cst) (rulename "sp"))))
Theorem:
(defthm imap-cst-address-branches-match-alt (implies (imap-cst-matchp cst "address") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" addr-name sp addr-adl sp addr-mailbox sp addr-host \")\"")))
Theorem:
(defthm imap-cst-addr-adl-branches-match-alt (implies (imap-cst-matchp cst "addr-adl") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-addr-host-branches-match-alt (implies (imap-cst-matchp cst "addr-host") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-addr-mailbox-branches-match-alt (implies (imap-cst-matchp cst "addr-mailbox") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-addr-name-branches-match-alt (implies (imap-cst-matchp cst "addr-name") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-append-branches-match-alt (implies (imap-cst-matchp cst "append") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"APPEND\" sp mailbox [ sp flag-list ] [ sp date-time ] sp literal")))
Theorem:
(defthm imap-cst-astring-branches-match-alt (implies (imap-cst-matchp cst "astring") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*astring-char / string")))
Theorem:
(defthm imap-cst-astring-char-branches-match-alt (implies (imap-cst-matchp cst "astring-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom-char / resp-specials")))
Theorem:
(defthm imap-cst-atom-branches-match-alt (implies (imap-cst-matchp cst "atom") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*atom-char")))
Theorem:
(defthm imap-cst-atom-char-branches-match-alt (implies (imap-cst-matchp cst "atom-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "<any CHAR except atom-specials>")))
Theorem:
(defthm imap-cst-atom-specials-branches-match-alt (implies (imap-cst-matchp cst "atom-specials") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" / \")\" / \"{\" / sp / ctl / list-wildcards / quoted-specials / resp-specials")))
Theorem:
(defthm imap-cst-authenticate-branches-match-alt (implies (imap-cst-matchp cst "authenticate") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"AUTHENTICATE\" sp auth-type *( crlf base64 )")))
Theorem:
(defthm imap-cst-auth-type-branches-match-alt (implies (imap-cst-matchp cst "auth-type") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom")))
Theorem:
(defthm imap-cst-base64-branches-match-alt (implies (imap-cst-matchp cst "base64") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( 4base64-char ) [ base64-terminal ]")))
Theorem:
(defthm imap-cst-base64-char-branches-match-alt (implies (imap-cst-matchp cst "base64-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha / digit / \"+\" / \"/\"")))
Theorem:
(defthm imap-cst-base64-terminal-branches-match-alt (implies (imap-cst-matchp cst "base64-terminal") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( 2base64-char \"==\" ) / ( 3base64-char \"=\" )")))
Theorem:
(defthm imap-cst-body-branches-match-alt (implies (imap-cst-matchp cst "body") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" ( body-type-1part / body-type-mpart ) \")\"")))
Theorem:
(defthm imap-cst-body-extension-branches-match-alt (implies (imap-cst-matchp cst "body-extension") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring / number / \"(\" body-extension *( sp body-extension ) \")\"")))
Theorem:
(defthm imap-cst-body-ext-1part-branches-match-alt (implies (imap-cst-matchp cst "body-ext-1part") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "body-fld-md5 [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]")))
Theorem:
(defthm imap-cst-body-ext-mpart-branches-match-alt (implies (imap-cst-matchp cst "body-ext-mpart") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "body-fld-param [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]")))
Theorem:
(defthm imap-cst-body-fields-branches-match-alt (implies (imap-cst-matchp cst "body-fields") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "body-fld-param sp body-fld-id sp body-fld-desc sp body-fld-enc sp body-fld-octets")))
Theorem:
(defthm imap-cst-body-fld-desc-branches-match-alt (implies (imap-cst-matchp cst "body-fld-desc") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-body-fld-dsp-branches-match-alt (implies (imap-cst-matchp cst "body-fld-dsp") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" string sp body-fld-param \")\" / nil")))
Theorem:
(defthm imap-cst-body-fld-enc-branches-match-alt (implies (imap-cst-matchp cst "body-fld-enc") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote ) / string")))
Theorem:
(defthm imap-cst-body-fld-id-branches-match-alt (implies (imap-cst-matchp cst "body-fld-id") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-body-fld-lang-branches-match-alt (implies (imap-cst-matchp cst "body-fld-lang") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring / \"(\" string *( sp string ) \")\"")))
Theorem:
(defthm imap-cst-body-fld-loc-branches-match-alt (implies (imap-cst-matchp cst "body-fld-loc") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-body-fld-lines-branches-match-alt (implies (imap-cst-matchp cst "body-fld-lines") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "number")))
Theorem:
(defthm imap-cst-body-fld-md5-branches-match-alt (implies (imap-cst-matchp cst "body-fld-md5") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-body-fld-octets-branches-match-alt (implies (imap-cst-matchp cst "body-fld-octets") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "number")))
Theorem:
(defthm imap-cst-body-fld-param-branches-match-alt (implies (imap-cst-matchp cst "body-fld-param") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" string sp string *( sp string sp string ) \")\" / nil")))
Theorem:
(defthm imap-cst-body-type-1part-branches-match-alt (implies (imap-cst-matchp cst "body-type-1part") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( body-type-basic / body-type-msg / body-type-text ) [ sp body-ext-1part ]")))
Theorem:
(defthm imap-cst-body-type-basic-branches-match-alt (implies (imap-cst-matchp cst "body-type-basic") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "media-basic sp body-fields")))
Theorem:
(defthm imap-cst-body-type-mpart-branches-match-alt (implies (imap-cst-matchp cst "body-type-mpart") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*body sp media-subtype [ sp body-ext-mpart ]")))
Theorem:
(defthm imap-cst-body-type-msg-branches-match-alt (implies (imap-cst-matchp cst "body-type-msg") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "media-message sp body-fields sp envelope sp body sp body-fld-lines")))
Theorem:
(defthm imap-cst-body-type-text-branches-match-alt (implies (imap-cst-matchp cst "body-type-text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "media-text sp body-fields sp body-fld-lines")))
Theorem:
(defthm imap-cst-capability-branches-match-alt (implies (imap-cst-matchp cst "capability") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"AUTH=\" auth-type ) / atom")))
Theorem:
(defthm imap-cst-capability-data-branches-match-alt (implies (imap-cst-matchp cst "capability-data") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"CAPABILITY\" *( sp capability ) sp \"IMAP4rev1\" *( sp capability )")))
Theorem:
(defthm imap-cst-char8-branches-match-alt (implies (imap-cst-matchp cst "char8") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x1-FF")))
Theorem:
(defthm imap-cst-command-branches-match-alt (implies (imap-cst-matchp cst "command") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "tag sp ( command-any / command-auth / command-nonauth / command-select ) crlf")))
Theorem:
(defthm imap-cst-command-any-branches-match-alt (implies (imap-cst-matchp cst "command-any") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"CAPABILITY\" / \"LOGOUT\" / \"NOOP\" / x-command")))
Theorem:
(defthm imap-cst-command-auth-branches-match-alt (implies (imap-cst-matchp cst "command-auth") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "append / create / delete / examine / list / lsub / rename / select / status / subscribe / unsubscribe")))
Theorem:
(defthm imap-cst-command-nonauth-branches-match-alt (implies (imap-cst-matchp cst "command-nonauth") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "login / authenticate / \"STARTTLS\"")))
Theorem:
(defthm imap-cst-command-select-branches-match-alt (implies (imap-cst-matchp cst "command-select") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"CHECK\" / \"CLOSE\" / \"EXPUNGE\" / copy / fetch / store / uid / search")))
Theorem:
(defthm imap-cst-continue-req-branches-match-alt (implies (imap-cst-matchp cst "continue-req") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"+\" sp ( resp-text / base64 ) crlf")))
Theorem:
(defthm imap-cst-copy-branches-match-alt (implies (imap-cst-matchp cst "copy") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"COPY\" sp sequence-set sp mailbox")))
Theorem:
(defthm imap-cst-create-branches-match-alt (implies (imap-cst-matchp cst "create") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"CREATE\" sp mailbox")))
Theorem:
(defthm imap-cst-date-branches-match-alt (implies (imap-cst-matchp cst "date") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "date-text / dquote date-text dquote")))
Theorem:
(defthm imap-cst-date-day-branches-match-alt (implies (imap-cst-matchp cst "date-day") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*2digit")))
Theorem:
(defthm imap-cst-date-day-fixed-branches-match-alt (implies (imap-cst-matchp cst "date-day-fixed") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( sp digit ) / 2digit")))
Theorem:
(defthm imap-cst-date-month-branches-match-alt (implies (imap-cst-matchp cst "date-month") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"")))
Theorem:
(defthm imap-cst-date-text-branches-match-alt (implies (imap-cst-matchp cst "date-text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "date-day \"-\" date-month \"-\" date-year")))
Theorem:
(defthm imap-cst-date-year-branches-match-alt (implies (imap-cst-matchp cst "date-year") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "4digit")))
Theorem:
(defthm imap-cst-date-time-branches-match-alt (implies (imap-cst-matchp cst "date-time") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote date-day-fixed \"-\" date-month \"-\" date-year sp time sp zone dquote")))
Theorem:
(defthm imap-cst-delete-branches-match-alt (implies (imap-cst-matchp cst "delete") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"DELETE\" sp mailbox")))
Theorem:
(defthm imap-cst-digit-nz-branches-match-alt (implies (imap-cst-matchp cst "digit-nz") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x31-39")))
Theorem:
(defthm imap-cst-envelope-branches-match-alt (implies (imap-cst-matchp cst "envelope") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" env-date sp env-subject sp env-from sp env-sender sp env-reply-to sp env-to sp env-cc sp env-bcc sp env-in-reply-to sp env-message-id \")\"")))
Theorem:
(defthm imap-cst-env-bcc-branches-match-alt (implies (imap-cst-matchp cst "env-bcc") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-env-cc-branches-match-alt (implies (imap-cst-matchp cst "env-cc") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-env-date-branches-match-alt (implies (imap-cst-matchp cst "env-date") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-env-from-branches-match-alt (implies (imap-cst-matchp cst "env-from") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-env-in-reply-to-branches-match-alt (implies (imap-cst-matchp cst "env-in-reply-to") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-env-message-id-branches-match-alt (implies (imap-cst-matchp cst "env-message-id") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-env-reply-to-branches-match-alt (implies (imap-cst-matchp cst "env-reply-to") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-env-sender-branches-match-alt (implies (imap-cst-matchp cst "env-sender") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-env-subject-branches-match-alt (implies (imap-cst-matchp cst "env-subject") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nstring")))
Theorem:
(defthm imap-cst-env-to-branches-match-alt (implies (imap-cst-matchp cst "env-to") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" 1*address \")\" / nil")))
Theorem:
(defthm imap-cst-examine-branches-match-alt (implies (imap-cst-matchp cst "examine") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"EXAMINE\" sp mailbox")))
Theorem:
(defthm imap-cst-fetch-branches-match-alt (implies (imap-cst-matchp cst "fetch") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"FETCH\" sp sequence-set sp ( \"ALL\" / \"FULL\" / \"FAST\" / fetch-att / \"(\" fetch-att *( sp fetch-att ) \")\" )")))
Theorem:
(defthm imap-cst-fetch-att-branches-match-alt (implies (imap-cst-matchp cst "fetch-att") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"ENVELOPE\" / \"FLAGS\" / \"INTERNALDATE\" / \"RFC822\" [ \".HEADER\" / \".SIZE\" / \".TEXT\" ] / \"BODY\" [ \"STRUCTURE\" ] / \"UID\" / \"BODY\" section [ \"<\" number \".\" nz-number \">\" ] / \"BODY.PEEK\" section [ \"<\" number \".\" nz-number \">\" ]")))
Theorem:
(defthm imap-cst-flag-branches-match-alt (implies (imap-cst-matchp cst "flag") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\Answered\" / \"\\Flagged\" / \"\\Deleted\" / \"\\Seen\" / \"\\Draft\" / flag-keyword / flag-extension")))
Theorem:
(defthm imap-cst-flag-extension-branches-match-alt (implies (imap-cst-matchp cst "flag-extension") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\\" atom")))
Theorem:
(defthm imap-cst-flag-fetch-branches-match-alt (implies (imap-cst-matchp cst "flag-fetch") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "flag / \"\\Recent\"")))
Theorem:
(defthm imap-cst-flag-keyword-branches-match-alt (implies (imap-cst-matchp cst "flag-keyword") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom")))
Theorem:
(defthm imap-cst-flag-list-branches-match-alt (implies (imap-cst-matchp cst "flag-list") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" [ flag *( sp flag ) ] \")\"")))
Theorem:
(defthm imap-cst-flag-perm-branches-match-alt (implies (imap-cst-matchp cst "flag-perm") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "flag / \"\\*\"")))
Theorem:
(defthm imap-cst-greeting-branches-match-alt (implies (imap-cst-matchp cst "greeting") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"*\" sp ( resp-cond-auth / resp-cond-bye ) crlf")))
Theorem:
(defthm imap-cst-header-fld-name-branches-match-alt (implies (imap-cst-matchp cst "header-fld-name") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "astring")))
Theorem:
(defthm imap-cst-header-list-branches-match-alt (implies (imap-cst-matchp cst "header-list") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" header-fld-name *( sp header-fld-name ) \")\"")))
Theorem:
(defthm imap-cst-list-branches-match-alt (implies (imap-cst-matchp cst "list") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"LIST\" sp mailbox sp list-mailbox")))
Theorem:
(defthm imap-cst-list-mailbox-branches-match-alt (implies (imap-cst-matchp cst "list-mailbox") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*list-char / string")))
Theorem:
(defthm imap-cst-list-char-branches-match-alt (implies (imap-cst-matchp cst "list-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "atom-char / list-wildcards / resp-specials")))
Theorem:
(defthm imap-cst-list-wildcards-branches-match-alt (implies (imap-cst-matchp cst "list-wildcards") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"%\" / \"*\"")))
Theorem:
(defthm imap-cst-literal-branches-match-alt (implies (imap-cst-matchp cst "literal") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"{\" number \"}\" crlf *char8")))
Theorem:
(defthm imap-cst-login-branches-match-alt (implies (imap-cst-matchp cst "login") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"LOGIN\" sp userid sp password")))
Theorem:
(defthm imap-cst-lsub-branches-match-alt (implies (imap-cst-matchp cst "lsub") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"LSUB\" sp mailbox sp list-mailbox")))
Theorem:
(defthm imap-cst-mailbox-branches-match-alt (implies (imap-cst-matchp cst "mailbox") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"INBOX\" / astring")))
Theorem:
(defthm imap-cst-mailbox-data-branches-match-alt (implies (imap-cst-matchp cst "mailbox-data") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"FLAGS\" sp flag-list / \"LIST\" sp mailbox-list / \"LSUB\" sp mailbox-list / \"SEARCH\" *( sp nz-number ) / \"STATUS\" sp mailbox sp \"(\" [ status-att-list ] \")\" / number sp \"EXISTS\" / number sp \"RECENT\"")))
Theorem:
(defthm imap-cst-mailbox-list-branches-match-alt (implies (imap-cst-matchp cst "mailbox-list") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" [ mbx-list-flags ] \")\" sp ( dquote quoted-char dquote / nil ) sp mailbox")))
Theorem:
(defthm imap-cst-mbx-list-flags-branches-match-alt (implies (imap-cst-matchp cst "mbx-list-flags") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( mbx-list-oflag sp ) mbx-list-sflag *( sp mbx-list-oflag ) / mbx-list-oflag *( sp mbx-list-oflag )")))
Theorem:
(defthm imap-cst-mbx-list-oflag-branches-match-alt (implies (imap-cst-matchp cst "mbx-list-oflag") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\Noinferiors\" / flag-extension")))
Theorem:
(defthm imap-cst-mbx-list-sflag-branches-match-alt (implies (imap-cst-matchp cst "mbx-list-sflag") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\Noselect\" / \"\\Marked\" / \"\\Unmarked\"")))
Theorem:
(defthm imap-cst-media-basic-branches-match-alt (implies (imap-cst-matchp cst "media-basic") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( ( dquote ( \"APPLICATION\" / \"AUDIO\" / \"IMAGE\" / \"MESSAGE\" / \"VIDEO\" ) dquote ) / string ) sp media-subtype")))
Theorem:
(defthm imap-cst-media-message-branches-match-alt (implies (imap-cst-matchp cst "media-message") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote \"MESSAGE\" dquote sp dquote \"RFC822\" dquote")))
Theorem:
(defthm imap-cst-media-subtype-branches-match-alt (implies (imap-cst-matchp cst "media-subtype") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "string")))
Theorem:
(defthm imap-cst-media-text-branches-match-alt (implies (imap-cst-matchp cst "media-text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote \"TEXT\" dquote sp media-subtype")))
Theorem:
(defthm imap-cst-message-data-branches-match-alt (implies (imap-cst-matchp cst "message-data") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nz-number sp ( \"EXPUNGE\" / ( \"FETCH\" sp msg-att ) )")))
Theorem:
(defthm imap-cst-msg-att-branches-match-alt (implies (imap-cst-matchp cst "msg-att") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" ( msg-att-dynamic / msg-att-static ) *( sp ( msg-att-dynamic / msg-att-static ) ) \")\"")))
Theorem:
(defthm imap-cst-msg-att-dynamic-branches-match-alt (implies (imap-cst-matchp cst "msg-att-dynamic") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"FLAGS\" sp \"(\" [ flag-fetch *( sp flag-fetch ) ] \")\"")))
Theorem:
(defthm imap-cst-msg-att-static-branches-match-alt (implies (imap-cst-matchp cst "msg-att-static") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"ENVELOPE\" sp envelope / \"INTERNALDATE\" sp date-time / \"RFC822\" [ \".HEADER\" / \".TEXT\" ] sp nstring / \"RFC822.SIZE\" sp number / \"BODY\" [ \"STRUCTURE\" ] sp body / \"BODY\" section [ \"<\" number \">\" ] sp nstring / \"UID\" sp uniqueid")))
Theorem:
(defthm imap-cst-nil-branches-match-alt (implies (imap-cst-matchp cst "nil") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"NIL\"")))
Theorem:
(defthm imap-cst-nstring-branches-match-alt (implies (imap-cst-matchp cst "nstring") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "string / nil")))
Theorem:
(defthm imap-cst-number-branches-match-alt (implies (imap-cst-matchp cst "number") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*digit")))
Theorem:
(defthm imap-cst-nz-number-branches-match-alt (implies (imap-cst-matchp cst "nz-number") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "digit-nz *digit")))
Theorem:
(defthm imap-cst-password-branches-match-alt (implies (imap-cst-matchp cst "password") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "astring")))
Theorem:
(defthm imap-cst-quoted-branches-match-alt (implies (imap-cst-matchp cst "quoted") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote *quoted-char dquote")))
Theorem:
(defthm imap-cst-quoted-char-branches-match-alt (implies (imap-cst-matchp cst "quoted-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "<any TEXT-CHAR except quoted-specials> / \"\\\" quoted-specials")))
Theorem:
(defthm imap-cst-quoted-specials-branches-match-alt (implies (imap-cst-matchp cst "quoted-specials") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote / \"\\\"")))
Theorem:
(defthm imap-cst-rename-branches-match-alt (implies (imap-cst-matchp cst "rename") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"RENAME\" sp mailbox sp mailbox")))
Theorem:
(defthm imap-cst-response-branches-match-alt (implies (imap-cst-matchp cst "response") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( continue-req / response-data ) response-done")))
Theorem:
(defthm imap-cst-response-data-branches-match-alt (implies (imap-cst-matchp cst "response-data") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"*\" sp ( resp-cond-state / resp-cond-bye / mailbox-data / message-data / capability-data ) crlf")))
Theorem:
(defthm imap-cst-response-done-branches-match-alt (implies (imap-cst-matchp cst "response-done") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "response-tagged / response-fatal")))
Theorem:
(defthm imap-cst-response-fatal-branches-match-alt (implies (imap-cst-matchp cst "response-fatal") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"*\" sp resp-cond-bye crlf")))
Theorem:
(defthm imap-cst-response-tagged-branches-match-alt (implies (imap-cst-matchp cst "response-tagged") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "tag sp resp-cond-state crlf")))
Theorem:
(defthm imap-cst-resp-cond-auth-branches-match-alt (implies (imap-cst-matchp cst "resp-cond-auth") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"OK\" / \"PREAUTH\" ) sp resp-text")))
Theorem:
(defthm imap-cst-resp-cond-bye-branches-match-alt (implies (imap-cst-matchp cst "resp-cond-bye") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"BYE\" sp resp-text")))
Theorem:
(defthm imap-cst-resp-cond-state-branches-match-alt (implies (imap-cst-matchp cst "resp-cond-state") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"OK\" / \"NO\" / \"BAD\" ) sp resp-text")))
Theorem:
(defthm imap-cst-resp-specials-branches-match-alt (implies (imap-cst-matchp cst "resp-specials") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"]\"")))
Theorem:
(defthm imap-cst-resp-text-branches-match-alt (implies (imap-cst-matchp cst "resp-text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ \"[\" resp-text-code \"]\" sp ] text")))
Theorem:
(defthm imap-cst-resp-text-code-branches-match-alt (implies (imap-cst-matchp cst "resp-text-code") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"ALERT\" / \"BADCHARSET\" [ sp \"(\" astring *( sp astring ) \")\" ] / capability-data / \"PARSE\" / \"PERMANENTFLAGS\" sp \"(\" [ flag-perm *( sp flag-perm ) ] \")\" / \"READ-ONLY\" / \"READ-WRITE\" / \"TRYCREATE\" / \"UIDNEXT\" sp nz-number / \"UIDVALIDITY\" sp nz-number / \"UNSEEN\" sp nz-number / atom [ sp 1*<any TEXT-CHAR except \"]\"> ]")))
Theorem:
(defthm imap-cst-search-branches-match-alt (implies (imap-cst-matchp cst "search") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"SEARCH\" [ sp \"CHARSET\" sp astring ] 1*( sp search-key )")))
Theorem:
(defthm imap-cst-search-key-branches-match-alt (implies (imap-cst-matchp cst "search-key") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"ALL\" / \"ANSWERED\" / \"BCC\" sp astring / \"BEFORE\" sp date / \"BODY\" sp astring / \"CC\" sp astring / \"DELETED\" / \"FLAGGED\" / \"FROM\" sp astring / \"KEYWORD\" sp flag-keyword / \"NEW\" / \"OLD\" / \"ON\" sp date / \"RECENT\" / \"SEEN\" / \"SINCE\" sp date / \"SUBJECT\" sp astring / \"TEXT\" sp astring / \"TO\" sp astring / \"UNANSWERED\" / \"UNDELETED\" / \"UNFLAGGED\" / \"UNKEYWORD\" sp flag-keyword / \"UNSEEN\" / \"DRAFT\" / \"HEADER\" sp header-fld-name sp astring / \"LARGER\" sp number / \"NOT\" sp search-key / \"OR\" sp search-key sp search-key / \"SENTBEFORE\" sp date / \"SENTON\" sp date / \"SENTSINCE\" sp date / \"SMALLER\" sp number / \"UID\" sp sequence-set / \"UNDRAFT\" / sequence-set / \"(\" search-key *( sp search-key ) \")\"")))
Theorem:
(defthm imap-cst-section-branches-match-alt (implies (imap-cst-matchp cst "section") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"[\" [ section-spec ] \"]\"")))
Theorem:
(defthm imap-cst-section-msgtext-branches-match-alt (implies (imap-cst-matchp cst "section-msgtext") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"HEADER\" / \"HEADER.FIELDS\" [ \".NOT\" ] sp header-list / \"TEXT\"")))
Theorem:
(defthm imap-cst-section-part-branches-match-alt (implies (imap-cst-matchp cst "section-part") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nz-number *( \".\" nz-number )")))
Theorem:
(defthm imap-cst-section-spec-branches-match-alt (implies (imap-cst-matchp cst "section-spec") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "section-msgtext / ( section-part [ \".\" section-text ] )")))
Theorem:
(defthm imap-cst-section-text-branches-match-alt (implies (imap-cst-matchp cst "section-text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "section-msgtext / \"MIME\"")))
Theorem:
(defthm imap-cst-select-branches-match-alt (implies (imap-cst-matchp cst "select") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"SELECT\" sp mailbox")))
Theorem:
(defthm imap-cst-seq-number-branches-match-alt (implies (imap-cst-matchp cst "seq-number") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nz-number / \"*\"")))
Theorem:
(defthm imap-cst-seq-range-branches-match-alt (implies (imap-cst-matchp cst "seq-range") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "seq-number \":\" seq-number")))
Theorem:
(defthm imap-cst-sequence-set-branches-match-alt (implies (imap-cst-matchp cst "sequence-set") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( seq-number / seq-range ) *( \",\" sequence-set )")))
Theorem:
(defthm imap-cst-status-branches-match-alt (implies (imap-cst-matchp cst "status") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"STATUS\" sp mailbox sp \"(\" status-att *( sp status-att ) \")\"")))
Theorem:
(defthm imap-cst-status-att-branches-match-alt (implies (imap-cst-matchp cst "status-att") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"MESSAGES\" / \"RECENT\" / \"UIDNEXT\" / \"UIDVALIDITY\" / \"UNSEEN\"")))
Theorem:
(defthm imap-cst-status-att-list-branches-match-alt (implies (imap-cst-matchp cst "status-att-list") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "status-att sp number *( sp status-att sp number )")))
Theorem:
(defthm imap-cst-store-branches-match-alt (implies (imap-cst-matchp cst "store") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"STORE\" sp sequence-set sp store-att-flags")))
Theorem:
(defthm imap-cst-store-att-flags-branches-match-alt (implies (imap-cst-matchp cst "store-att-flags") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( [ \"+\" / \"-\" ] \"FLAGS\" [ \".SILENT\" ] ) sp ( flag-list / ( flag *( sp flag ) ) )")))
Theorem:
(defthm imap-cst-string-branches-match-alt (implies (imap-cst-matchp cst "string") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "quoted / literal")))
Theorem:
(defthm imap-cst-subscribe-branches-match-alt (implies (imap-cst-matchp cst "subscribe") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"SUBSCRIBE\" sp mailbox")))
Theorem:
(defthm imap-cst-tag-branches-match-alt (implies (imap-cst-matchp cst "tag") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*<any ASTRING-CHAR except \"+\">")))
Theorem:
(defthm imap-cst-text-branches-match-alt (implies (imap-cst-matchp cst "text") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*text-char")))
Theorem:
(defthm imap-cst-text-char-branches-match-alt (implies (imap-cst-matchp cst "text-char") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "<any CHAR except CR and LF>")))
Theorem:
(defthm imap-cst-time-branches-match-alt (implies (imap-cst-matchp cst "time") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "2digit \":\" 2digit \":\" 2digit")))
Theorem:
(defthm imap-cst-uid-branches-match-alt (implies (imap-cst-matchp cst "uid") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"UID\" sp ( copy / fetch / search / store )")))
Theorem:
(defthm imap-cst-uniqueid-branches-match-alt (implies (imap-cst-matchp cst "uniqueid") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "nz-number")))
Theorem:
(defthm imap-cst-unsubscribe-branches-match-alt (implies (imap-cst-matchp cst "unsubscribe") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"UNSUBSCRIBE\" sp mailbox")))
Theorem:
(defthm imap-cst-userid-branches-match-alt (implies (imap-cst-matchp cst "userid") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "astring")))
Theorem:
(defthm imap-cst-x-command-branches-match-alt (implies (imap-cst-matchp cst "x-command") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"X\" atom <experimental command arguments>")))
Theorem:
(defthm imap-cst-zone-branches-match-alt (implies (imap-cst-matchp cst "zone") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"+\" / \"-\" ) 4digit")))
Theorem:
(defthm imap-cst-alpha-branches-match-alt (implies (imap-cst-matchp cst "alpha") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x41-5A / %x61-7A")))
Theorem:
(defthm imap-cst-crlf-branches-match-alt (implies (imap-cst-matchp cst "crlf") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cr lf")))
Theorem:
(defthm imap-cst-cr-branches-match-alt (implies (imap-cst-matchp cst "cr") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xD")))
Theorem:
(defthm imap-cst-ctl-branches-match-alt (implies (imap-cst-matchp cst "ctl") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x0-1F / %x7F")))
Theorem:
(defthm imap-cst-digit-branches-match-alt (implies (imap-cst-matchp cst "digit") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30-39")))
Theorem:
(defthm imap-cst-dquote-branches-match-alt (implies (imap-cst-matchp cst "dquote") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x22")))
Theorem:
(defthm imap-cst-lf-branches-match-alt (implies (imap-cst-matchp cst "lf") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xA")))
Theorem:
(defthm imap-cst-sp-branches-match-alt (implies (imap-cst-matchp cst "sp") (imap-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20")))
Theorem:
(defthm imap-cst-address-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" addr-name sp addr-adl sp addr-mailbox sp addr-host \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" addr-name sp addr-adl sp addr-mailbox sp addr-host \")\""))))
Theorem:
(defthm imap-cst-addr-adl-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-addr-host-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-addr-mailbox-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-addr-name-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-append-concs (implies (imap-cst-list-list-alt-matchp cstss "\"APPEND\" sp mailbox [ sp flag-list ] [ sp date-time ] sp literal") (or (imap-cst-list-list-conc-matchp cstss "\"APPEND\" sp mailbox [ sp flag-list ] [ sp date-time ] sp literal"))))
Theorem:
(defthm imap-cst-astring-concs (implies (imap-cst-list-list-alt-matchp cstss "1*astring-char / string") (or (imap-cst-list-list-conc-matchp cstss "1*astring-char") (imap-cst-list-list-conc-matchp cstss "string"))))
Theorem:
(defthm imap-cst-astring-char-concs (implies (imap-cst-list-list-alt-matchp cstss "atom-char / resp-specials") (or (imap-cst-list-list-conc-matchp cstss "atom-char") (imap-cst-list-list-conc-matchp cstss "resp-specials"))))
Theorem:
(defthm imap-cst-atom-concs (implies (imap-cst-list-list-alt-matchp cstss "1*atom-char") (or (imap-cst-list-list-conc-matchp cstss "1*atom-char"))))
Theorem:
(defthm imap-cst-atom-char-concs (implies (imap-cst-list-list-alt-matchp cstss "<any CHAR except atom-specials>") (or (imap-cst-list-list-conc-matchp cstss "<any CHAR except atom-specials>"))))
Theorem:
(defthm imap-cst-atom-specials-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" / \")\" / \"{\" / sp / ctl / list-wildcards / quoted-specials / resp-specials") (or (imap-cst-list-list-conc-matchp cstss "\"(\"") (imap-cst-list-list-conc-matchp cstss "\")\"") (imap-cst-list-list-conc-matchp cstss "\"{\"") (imap-cst-list-list-conc-matchp cstss "sp") (imap-cst-list-list-conc-matchp cstss "ctl") (imap-cst-list-list-conc-matchp cstss "list-wildcards") (imap-cst-list-list-conc-matchp cstss "quoted-specials") (imap-cst-list-list-conc-matchp cstss "resp-specials"))))
Theorem:
(defthm imap-cst-authenticate-concs (implies (imap-cst-list-list-alt-matchp cstss "\"AUTHENTICATE\" sp auth-type *( crlf base64 )") (or (imap-cst-list-list-conc-matchp cstss "\"AUTHENTICATE\" sp auth-type *( crlf base64 )"))))
Theorem:
(defthm imap-cst-auth-type-concs (implies (imap-cst-list-list-alt-matchp cstss "atom") (or (imap-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm imap-cst-base64-concs (implies (imap-cst-list-list-alt-matchp cstss "*( 4base64-char ) [ base64-terminal ]") (or (imap-cst-list-list-conc-matchp cstss "*( 4base64-char ) [ base64-terminal ]"))))
Theorem:
(defthm imap-cst-base64-char-concs (implies (imap-cst-list-list-alt-matchp cstss "alpha / digit / \"+\" / \"/\"") (or (imap-cst-list-list-conc-matchp cstss "alpha") (imap-cst-list-list-conc-matchp cstss "digit") (imap-cst-list-list-conc-matchp cstss "\"+\"") (imap-cst-list-list-conc-matchp cstss "\"/\""))))
Theorem:
(defthm imap-cst-base64-terminal-concs (implies (imap-cst-list-list-alt-matchp cstss "( 2base64-char \"==\" ) / ( 3base64-char \"=\" )") (or (imap-cst-list-list-conc-matchp cstss "( 2base64-char \"==\" )") (imap-cst-list-list-conc-matchp cstss "( 3base64-char \"=\" )"))))
Theorem:
(defthm imap-cst-body-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" ( body-type-1part / body-type-mpart ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" ( body-type-1part / body-type-mpart ) \")\""))))
Theorem:
(defthm imap-cst-body-extension-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring / number / \"(\" body-extension *( sp body-extension ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "nstring") (imap-cst-list-list-conc-matchp cstss "number") (imap-cst-list-list-conc-matchp cstss "\"(\" body-extension *( sp body-extension ) \")\""))))
Theorem:
(defthm imap-cst-body-ext-1part-concs (implies (imap-cst-list-list-alt-matchp cstss "body-fld-md5 [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]") (or (imap-cst-list-list-conc-matchp cstss "body-fld-md5 [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]"))))
Theorem:
(defthm imap-cst-body-ext-mpart-concs (implies (imap-cst-list-list-alt-matchp cstss "body-fld-param [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]") (or (imap-cst-list-list-conc-matchp cstss "body-fld-param [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]"))))
Theorem:
(defthm imap-cst-body-fields-concs (implies (imap-cst-list-list-alt-matchp cstss "body-fld-param sp body-fld-id sp body-fld-desc sp body-fld-enc sp body-fld-octets") (or (imap-cst-list-list-conc-matchp cstss "body-fld-param sp body-fld-id sp body-fld-desc sp body-fld-enc sp body-fld-octets"))))
Theorem:
(defthm imap-cst-body-fld-desc-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-body-fld-dsp-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" string sp body-fld-param \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" string sp body-fld-param \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-body-fld-enc-concs (implies (imap-cst-list-list-alt-matchp cstss "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote ) / string") (or (imap-cst-list-list-conc-matchp cstss "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote )") (imap-cst-list-list-conc-matchp cstss "string"))))
Theorem:
(defthm imap-cst-body-fld-id-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lang-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring / \"(\" string *( sp string ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "nstring") (imap-cst-list-list-conc-matchp cstss "\"(\" string *( sp string ) \")\""))))
Theorem:
(defthm imap-cst-body-fld-loc-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lines-concs (implies (imap-cst-list-list-alt-matchp cstss "number") (or (imap-cst-list-list-conc-matchp cstss "number"))))
Theorem:
(defthm imap-cst-body-fld-md5-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-body-fld-octets-concs (implies (imap-cst-list-list-alt-matchp cstss "number") (or (imap-cst-list-list-conc-matchp cstss "number"))))
Theorem:
(defthm imap-cst-body-fld-param-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" string sp string *( sp string sp string ) \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" string sp string *( sp string sp string ) \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-body-type-1part-concs (implies (imap-cst-list-list-alt-matchp cstss "( body-type-basic / body-type-msg / body-type-text ) [ sp body-ext-1part ]") (or (imap-cst-list-list-conc-matchp cstss "( body-type-basic / body-type-msg / body-type-text ) [ sp body-ext-1part ]"))))
Theorem:
(defthm imap-cst-body-type-basic-concs (implies (imap-cst-list-list-alt-matchp cstss "media-basic sp body-fields") (or (imap-cst-list-list-conc-matchp cstss "media-basic sp body-fields"))))
Theorem:
(defthm imap-cst-body-type-mpart-concs (implies (imap-cst-list-list-alt-matchp cstss "1*body sp media-subtype [ sp body-ext-mpart ]") (or (imap-cst-list-list-conc-matchp cstss "1*body sp media-subtype [ sp body-ext-mpart ]"))))
Theorem:
(defthm imap-cst-body-type-msg-concs (implies (imap-cst-list-list-alt-matchp cstss "media-message sp body-fields sp envelope sp body sp body-fld-lines") (or (imap-cst-list-list-conc-matchp cstss "media-message sp body-fields sp envelope sp body sp body-fld-lines"))))
Theorem:
(defthm imap-cst-body-type-text-concs (implies (imap-cst-list-list-alt-matchp cstss "media-text sp body-fields sp body-fld-lines") (or (imap-cst-list-list-conc-matchp cstss "media-text sp body-fields sp body-fld-lines"))))
Theorem:
(defthm imap-cst-capability-concs (implies (imap-cst-list-list-alt-matchp cstss "( \"AUTH=\" auth-type ) / atom") (or (imap-cst-list-list-conc-matchp cstss "( \"AUTH=\" auth-type )") (imap-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm imap-cst-capability-data-concs (implies (imap-cst-list-list-alt-matchp cstss "\"CAPABILITY\" *( sp capability ) sp \"IMAP4rev1\" *( sp capability )") (or (imap-cst-list-list-conc-matchp cstss "\"CAPABILITY\" *( sp capability ) sp \"IMAP4rev1\" *( sp capability )"))))
Theorem:
(defthm imap-cst-char8-concs (implies (imap-cst-list-list-alt-matchp cstss "%x1-FF") (or (imap-cst-list-list-conc-matchp cstss "%x1-FF"))))
Theorem:
(defthm imap-cst-command-concs (implies (imap-cst-list-list-alt-matchp cstss "tag sp ( command-any / command-auth / command-nonauth / command-select ) crlf") (or (imap-cst-list-list-conc-matchp cstss "tag sp ( command-any / command-auth / command-nonauth / command-select ) crlf"))))
Theorem:
(defthm imap-cst-command-any-concs (implies (imap-cst-list-list-alt-matchp cstss "\"CAPABILITY\" / \"LOGOUT\" / \"NOOP\" / x-command") (or (imap-cst-list-list-conc-matchp cstss "\"CAPABILITY\"") (imap-cst-list-list-conc-matchp cstss "\"LOGOUT\"") (imap-cst-list-list-conc-matchp cstss "\"NOOP\"") (imap-cst-list-list-conc-matchp cstss "x-command"))))
Theorem:
(defthm imap-cst-command-auth-concs (implies (imap-cst-list-list-alt-matchp cstss "append / create / delete / examine / list / lsub / rename / select / status / subscribe / unsubscribe") (or (imap-cst-list-list-conc-matchp cstss "append") (imap-cst-list-list-conc-matchp cstss "create") (imap-cst-list-list-conc-matchp cstss "delete") (imap-cst-list-list-conc-matchp cstss "examine") (imap-cst-list-list-conc-matchp cstss "list") (imap-cst-list-list-conc-matchp cstss "lsub") (imap-cst-list-list-conc-matchp cstss "rename") (imap-cst-list-list-conc-matchp cstss "select") (imap-cst-list-list-conc-matchp cstss "status") (imap-cst-list-list-conc-matchp cstss "subscribe") (imap-cst-list-list-conc-matchp cstss "unsubscribe"))))
Theorem:
(defthm imap-cst-command-nonauth-concs (implies (imap-cst-list-list-alt-matchp cstss "login / authenticate / \"STARTTLS\"") (or (imap-cst-list-list-conc-matchp cstss "login") (imap-cst-list-list-conc-matchp cstss "authenticate") (imap-cst-list-list-conc-matchp cstss "\"STARTTLS\""))))
Theorem:
(defthm imap-cst-command-select-concs (implies (imap-cst-list-list-alt-matchp cstss "\"CHECK\" / \"CLOSE\" / \"EXPUNGE\" / copy / fetch / store / uid / search") (or (imap-cst-list-list-conc-matchp cstss "\"CHECK\"") (imap-cst-list-list-conc-matchp cstss "\"CLOSE\"") (imap-cst-list-list-conc-matchp cstss "\"EXPUNGE\"") (imap-cst-list-list-conc-matchp cstss "copy") (imap-cst-list-list-conc-matchp cstss "fetch") (imap-cst-list-list-conc-matchp cstss "store") (imap-cst-list-list-conc-matchp cstss "uid") (imap-cst-list-list-conc-matchp cstss "search"))))
Theorem:
(defthm imap-cst-continue-req-concs (implies (imap-cst-list-list-alt-matchp cstss "\"+\" sp ( resp-text / base64 ) crlf") (or (imap-cst-list-list-conc-matchp cstss "\"+\" sp ( resp-text / base64 ) crlf"))))
Theorem:
(defthm imap-cst-copy-concs (implies (imap-cst-list-list-alt-matchp cstss "\"COPY\" sp sequence-set sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"COPY\" sp sequence-set sp mailbox"))))
Theorem:
(defthm imap-cst-create-concs (implies (imap-cst-list-list-alt-matchp cstss "\"CREATE\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"CREATE\" sp mailbox"))))
Theorem:
(defthm imap-cst-date-concs (implies (imap-cst-list-list-alt-matchp cstss "date-text / dquote date-text dquote") (or (imap-cst-list-list-conc-matchp cstss "date-text") (imap-cst-list-list-conc-matchp cstss "dquote date-text dquote"))))
Theorem:
(defthm imap-cst-date-day-concs (implies (imap-cst-list-list-alt-matchp cstss "1*2digit") (or (imap-cst-list-list-conc-matchp cstss "1*2digit"))))
Theorem:
(defthm imap-cst-date-day-fixed-concs (implies (imap-cst-list-list-alt-matchp cstss "( sp digit ) / 2digit") (or (imap-cst-list-list-conc-matchp cstss "( sp digit )") (imap-cst-list-list-conc-matchp cstss "2digit"))))
Theorem:
(defthm imap-cst-date-month-concs (implies (imap-cst-list-list-alt-matchp cstss "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"") (or (imap-cst-list-list-conc-matchp cstss "\"Jan\"") (imap-cst-list-list-conc-matchp cstss "\"Feb\"") (imap-cst-list-list-conc-matchp cstss "\"Mar\"") (imap-cst-list-list-conc-matchp cstss "\"Apr\"") (imap-cst-list-list-conc-matchp cstss "\"May\"") (imap-cst-list-list-conc-matchp cstss "\"Jun\"") (imap-cst-list-list-conc-matchp cstss "\"Jul\"") (imap-cst-list-list-conc-matchp cstss "\"Aug\"") (imap-cst-list-list-conc-matchp cstss "\"Sep\"") (imap-cst-list-list-conc-matchp cstss "\"Oct\"") (imap-cst-list-list-conc-matchp cstss "\"Nov\"") (imap-cst-list-list-conc-matchp cstss "\"Dec\""))))
Theorem:
(defthm imap-cst-date-text-concs (implies (imap-cst-list-list-alt-matchp cstss "date-day \"-\" date-month \"-\" date-year") (or (imap-cst-list-list-conc-matchp cstss "date-day \"-\" date-month \"-\" date-year"))))
Theorem:
(defthm imap-cst-date-year-concs (implies (imap-cst-list-list-alt-matchp cstss "4digit") (or (imap-cst-list-list-conc-matchp cstss "4digit"))))
Theorem:
(defthm imap-cst-date-time-concs (implies (imap-cst-list-list-alt-matchp cstss "dquote date-day-fixed \"-\" date-month \"-\" date-year sp time sp zone dquote") (or (imap-cst-list-list-conc-matchp cstss "dquote date-day-fixed \"-\" date-month \"-\" date-year sp time sp zone dquote"))))
Theorem:
(defthm imap-cst-delete-concs (implies (imap-cst-list-list-alt-matchp cstss "\"DELETE\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"DELETE\" sp mailbox"))))
Theorem:
(defthm imap-cst-digit-nz-concs (implies (imap-cst-list-list-alt-matchp cstss "%x31-39") (or (imap-cst-list-list-conc-matchp cstss "%x31-39"))))
Theorem:
(defthm imap-cst-envelope-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" env-date sp env-subject sp env-from sp env-sender sp env-reply-to sp env-to sp env-cc sp env-bcc sp env-in-reply-to sp env-message-id \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" env-date sp env-subject sp env-from sp env-sender sp env-reply-to sp env-to sp env-cc sp env-bcc sp env-in-reply-to sp env-message-id \")\""))))
Theorem:
(defthm imap-cst-env-bcc-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-env-cc-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-env-date-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-env-from-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-env-in-reply-to-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-env-message-id-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-env-reply-to-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-env-sender-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-env-subject-concs (implies (imap-cst-list-list-alt-matchp cstss "nstring") (or (imap-cst-list-list-conc-matchp cstss "nstring"))))
Theorem:
(defthm imap-cst-env-to-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" 1*address \")\" / nil") (or (imap-cst-list-list-conc-matchp cstss "\"(\" 1*address \")\"") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-examine-concs (implies (imap-cst-list-list-alt-matchp cstss "\"EXAMINE\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"EXAMINE\" sp mailbox"))))
Theorem:
(defthm imap-cst-fetch-concs (implies (imap-cst-list-list-alt-matchp cstss "\"FETCH\" sp sequence-set sp ( \"ALL\" / \"FULL\" / \"FAST\" / fetch-att / \"(\" fetch-att *( sp fetch-att ) \")\" )") (or (imap-cst-list-list-conc-matchp cstss "\"FETCH\" sp sequence-set sp ( \"ALL\" / \"FULL\" / \"FAST\" / fetch-att / \"(\" fetch-att *( sp fetch-att ) \")\" )"))))
Theorem:
(defthm imap-cst-fetch-att-concs (implies (imap-cst-list-list-alt-matchp cstss "\"ENVELOPE\" / \"FLAGS\" / \"INTERNALDATE\" / \"RFC822\" [ \".HEADER\" / \".SIZE\" / \".TEXT\" ] / \"BODY\" [ \"STRUCTURE\" ] / \"UID\" / \"BODY\" section [ \"<\" number \".\" nz-number \">\" ] / \"BODY.PEEK\" section [ \"<\" number \".\" nz-number \">\" ]") (or (imap-cst-list-list-conc-matchp cstss "\"ENVELOPE\"") (imap-cst-list-list-conc-matchp cstss "\"FLAGS\"") (imap-cst-list-list-conc-matchp cstss "\"INTERNALDATE\"") (imap-cst-list-list-conc-matchp cstss "\"RFC822\" [ \".HEADER\" / \".SIZE\" / \".TEXT\" ]") (imap-cst-list-list-conc-matchp cstss "\"BODY\" [ \"STRUCTURE\" ]") (imap-cst-list-list-conc-matchp cstss "\"UID\"") (imap-cst-list-list-conc-matchp cstss "\"BODY\" section [ \"<\" number \".\" nz-number \">\" ]") (imap-cst-list-list-conc-matchp cstss "\"BODY.PEEK\" section [ \"<\" number \".\" nz-number \">\" ]"))))
Theorem:
(defthm imap-cst-flag-concs (implies (imap-cst-list-list-alt-matchp cstss "\"\\Answered\" / \"\\Flagged\" / \"\\Deleted\" / \"\\Seen\" / \"\\Draft\" / flag-keyword / flag-extension") (or (imap-cst-list-list-conc-matchp cstss "\"\\Answered\"") (imap-cst-list-list-conc-matchp cstss "\"\\Flagged\"") (imap-cst-list-list-conc-matchp cstss "\"\\Deleted\"") (imap-cst-list-list-conc-matchp cstss "\"\\Seen\"") (imap-cst-list-list-conc-matchp cstss "\"\\Draft\"") (imap-cst-list-list-conc-matchp cstss "flag-keyword") (imap-cst-list-list-conc-matchp cstss "flag-extension"))))
Theorem:
(defthm imap-cst-flag-extension-concs (implies (imap-cst-list-list-alt-matchp cstss "\"\\\" atom") (or (imap-cst-list-list-conc-matchp cstss "\"\\\" atom"))))
Theorem:
(defthm imap-cst-flag-fetch-concs (implies (imap-cst-list-list-alt-matchp cstss "flag / \"\\Recent\"") (or (imap-cst-list-list-conc-matchp cstss "flag") (imap-cst-list-list-conc-matchp cstss "\"\\Recent\""))))
Theorem:
(defthm imap-cst-flag-keyword-concs (implies (imap-cst-list-list-alt-matchp cstss "atom") (or (imap-cst-list-list-conc-matchp cstss "atom"))))
Theorem:
(defthm imap-cst-flag-list-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" [ flag *( sp flag ) ] \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" [ flag *( sp flag ) ] \")\""))))
Theorem:
(defthm imap-cst-flag-perm-concs (implies (imap-cst-list-list-alt-matchp cstss "flag / \"\\*\"") (or (imap-cst-list-list-conc-matchp cstss "flag") (imap-cst-list-list-conc-matchp cstss "\"\\*\""))))
Theorem:
(defthm imap-cst-greeting-concs (implies (imap-cst-list-list-alt-matchp cstss "\"*\" sp ( resp-cond-auth / resp-cond-bye ) crlf") (or (imap-cst-list-list-conc-matchp cstss "\"*\" sp ( resp-cond-auth / resp-cond-bye ) crlf"))))
Theorem:
(defthm imap-cst-header-fld-name-concs (implies (imap-cst-list-list-alt-matchp cstss "astring") (or (imap-cst-list-list-conc-matchp cstss "astring"))))
Theorem:
(defthm imap-cst-header-list-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" header-fld-name *( sp header-fld-name ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" header-fld-name *( sp header-fld-name ) \")\""))))
Theorem:
(defthm imap-cst-list-concs (implies (imap-cst-list-list-alt-matchp cstss "\"LIST\" sp mailbox sp list-mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"LIST\" sp mailbox sp list-mailbox"))))
Theorem:
(defthm imap-cst-list-mailbox-concs (implies (imap-cst-list-list-alt-matchp cstss "1*list-char / string") (or (imap-cst-list-list-conc-matchp cstss "1*list-char") (imap-cst-list-list-conc-matchp cstss "string"))))
Theorem:
(defthm imap-cst-list-char-concs (implies (imap-cst-list-list-alt-matchp cstss "atom-char / list-wildcards / resp-specials") (or (imap-cst-list-list-conc-matchp cstss "atom-char") (imap-cst-list-list-conc-matchp cstss "list-wildcards") (imap-cst-list-list-conc-matchp cstss "resp-specials"))))
Theorem:
(defthm imap-cst-list-wildcards-concs (implies (imap-cst-list-list-alt-matchp cstss "\"%\" / \"*\"") (or (imap-cst-list-list-conc-matchp cstss "\"%\"") (imap-cst-list-list-conc-matchp cstss "\"*\""))))
Theorem:
(defthm imap-cst-literal-concs (implies (imap-cst-list-list-alt-matchp cstss "\"{\" number \"}\" crlf *char8") (or (imap-cst-list-list-conc-matchp cstss "\"{\" number \"}\" crlf *char8"))))
Theorem:
(defthm imap-cst-login-concs (implies (imap-cst-list-list-alt-matchp cstss "\"LOGIN\" sp userid sp password") (or (imap-cst-list-list-conc-matchp cstss "\"LOGIN\" sp userid sp password"))))
Theorem:
(defthm imap-cst-lsub-concs (implies (imap-cst-list-list-alt-matchp cstss "\"LSUB\" sp mailbox sp list-mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"LSUB\" sp mailbox sp list-mailbox"))))
Theorem:
(defthm imap-cst-mailbox-concs (implies (imap-cst-list-list-alt-matchp cstss "\"INBOX\" / astring") (or (imap-cst-list-list-conc-matchp cstss "\"INBOX\"") (imap-cst-list-list-conc-matchp cstss "astring"))))
Theorem:
(defthm imap-cst-mailbox-data-concs (implies (imap-cst-list-list-alt-matchp cstss "\"FLAGS\" sp flag-list / \"LIST\" sp mailbox-list / \"LSUB\" sp mailbox-list / \"SEARCH\" *( sp nz-number ) / \"STATUS\" sp mailbox sp \"(\" [ status-att-list ] \")\" / number sp \"EXISTS\" / number sp \"RECENT\"") (or (imap-cst-list-list-conc-matchp cstss "\"FLAGS\" sp flag-list") (imap-cst-list-list-conc-matchp cstss "\"LIST\" sp mailbox-list") (imap-cst-list-list-conc-matchp cstss "\"LSUB\" sp mailbox-list") (imap-cst-list-list-conc-matchp cstss "\"SEARCH\" *( sp nz-number )") (imap-cst-list-list-conc-matchp cstss "\"STATUS\" sp mailbox sp \"(\" [ status-att-list ] \")\"") (imap-cst-list-list-conc-matchp cstss "number sp \"EXISTS\"") (imap-cst-list-list-conc-matchp cstss "number sp \"RECENT\""))))
Theorem:
(defthm imap-cst-mailbox-list-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" [ mbx-list-flags ] \")\" sp ( dquote quoted-char dquote / nil ) sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"(\" [ mbx-list-flags ] \")\" sp ( dquote quoted-char dquote / nil ) sp mailbox"))))
Theorem:
(defthm imap-cst-mbx-list-flags-concs (implies (imap-cst-list-list-alt-matchp cstss "*( mbx-list-oflag sp ) mbx-list-sflag *( sp mbx-list-oflag ) / mbx-list-oflag *( sp mbx-list-oflag )") (or (imap-cst-list-list-conc-matchp cstss "*( mbx-list-oflag sp ) mbx-list-sflag *( sp mbx-list-oflag )") (imap-cst-list-list-conc-matchp cstss "mbx-list-oflag *( sp mbx-list-oflag )"))))
Theorem:
(defthm imap-cst-mbx-list-oflag-concs (implies (imap-cst-list-list-alt-matchp cstss "\"\\Noinferiors\" / flag-extension") (or (imap-cst-list-list-conc-matchp cstss "\"\\Noinferiors\"") (imap-cst-list-list-conc-matchp cstss "flag-extension"))))
Theorem:
(defthm imap-cst-mbx-list-sflag-concs (implies (imap-cst-list-list-alt-matchp cstss "\"\\Noselect\" / \"\\Marked\" / \"\\Unmarked\"") (or (imap-cst-list-list-conc-matchp cstss "\"\\Noselect\"") (imap-cst-list-list-conc-matchp cstss "\"\\Marked\"") (imap-cst-list-list-conc-matchp cstss "\"\\Unmarked\""))))
Theorem:
(defthm imap-cst-media-basic-concs (implies (imap-cst-list-list-alt-matchp cstss "( ( dquote ( \"APPLICATION\" / \"AUDIO\" / \"IMAGE\" / \"MESSAGE\" / \"VIDEO\" ) dquote ) / string ) sp media-subtype") (or (imap-cst-list-list-conc-matchp cstss "( ( dquote ( \"APPLICATION\" / \"AUDIO\" / \"IMAGE\" / \"MESSAGE\" / \"VIDEO\" ) dquote ) / string ) sp media-subtype"))))
Theorem:
(defthm imap-cst-media-message-concs (implies (imap-cst-list-list-alt-matchp cstss "dquote \"MESSAGE\" dquote sp dquote \"RFC822\" dquote") (or (imap-cst-list-list-conc-matchp cstss "dquote \"MESSAGE\" dquote sp dquote \"RFC822\" dquote"))))
Theorem:
(defthm imap-cst-media-subtype-concs (implies (imap-cst-list-list-alt-matchp cstss "string") (or (imap-cst-list-list-conc-matchp cstss "string"))))
Theorem:
(defthm imap-cst-media-text-concs (implies (imap-cst-list-list-alt-matchp cstss "dquote \"TEXT\" dquote sp media-subtype") (or (imap-cst-list-list-conc-matchp cstss "dquote \"TEXT\" dquote sp media-subtype"))))
Theorem:
(defthm imap-cst-message-data-concs (implies (imap-cst-list-list-alt-matchp cstss "nz-number sp ( \"EXPUNGE\" / ( \"FETCH\" sp msg-att ) )") (or (imap-cst-list-list-conc-matchp cstss "nz-number sp ( \"EXPUNGE\" / ( \"FETCH\" sp msg-att ) )"))))
Theorem:
(defthm imap-cst-msg-att-concs (implies (imap-cst-list-list-alt-matchp cstss "\"(\" ( msg-att-dynamic / msg-att-static ) *( sp ( msg-att-dynamic / msg-att-static ) ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"(\" ( msg-att-dynamic / msg-att-static ) *( sp ( msg-att-dynamic / msg-att-static ) ) \")\""))))
Theorem:
(defthm imap-cst-msg-att-dynamic-concs (implies (imap-cst-list-list-alt-matchp cstss "\"FLAGS\" sp \"(\" [ flag-fetch *( sp flag-fetch ) ] \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"FLAGS\" sp \"(\" [ flag-fetch *( sp flag-fetch ) ] \")\""))))
Theorem:
(defthm imap-cst-msg-att-static-concs (implies (imap-cst-list-list-alt-matchp cstss "\"ENVELOPE\" sp envelope / \"INTERNALDATE\" sp date-time / \"RFC822\" [ \".HEADER\" / \".TEXT\" ] sp nstring / \"RFC822.SIZE\" sp number / \"BODY\" [ \"STRUCTURE\" ] sp body / \"BODY\" section [ \"<\" number \">\" ] sp nstring / \"UID\" sp uniqueid") (or (imap-cst-list-list-conc-matchp cstss "\"ENVELOPE\" sp envelope") (imap-cst-list-list-conc-matchp cstss "\"INTERNALDATE\" sp date-time") (imap-cst-list-list-conc-matchp cstss "\"RFC822\" [ \".HEADER\" / \".TEXT\" ] sp nstring") (imap-cst-list-list-conc-matchp cstss "\"RFC822.SIZE\" sp number") (imap-cst-list-list-conc-matchp cstss "\"BODY\" [ \"STRUCTURE\" ] sp body") (imap-cst-list-list-conc-matchp cstss "\"BODY\" section [ \"<\" number \">\" ] sp nstring") (imap-cst-list-list-conc-matchp cstss "\"UID\" sp uniqueid"))))
Theorem:
(defthm imap-cst-nil-concs (implies (imap-cst-list-list-alt-matchp cstss "\"NIL\"") (or (imap-cst-list-list-conc-matchp cstss "\"NIL\""))))
Theorem:
(defthm imap-cst-nstring-concs (implies (imap-cst-list-list-alt-matchp cstss "string / nil") (or (imap-cst-list-list-conc-matchp cstss "string") (imap-cst-list-list-conc-matchp cstss "nil"))))
Theorem:
(defthm imap-cst-number-concs (implies (imap-cst-list-list-alt-matchp cstss "1*digit") (or (imap-cst-list-list-conc-matchp cstss "1*digit"))))
Theorem:
(defthm imap-cst-nz-number-concs (implies (imap-cst-list-list-alt-matchp cstss "digit-nz *digit") (or (imap-cst-list-list-conc-matchp cstss "digit-nz *digit"))))
Theorem:
(defthm imap-cst-password-concs (implies (imap-cst-list-list-alt-matchp cstss "astring") (or (imap-cst-list-list-conc-matchp cstss "astring"))))
Theorem:
(defthm imap-cst-quoted-concs (implies (imap-cst-list-list-alt-matchp cstss "dquote *quoted-char dquote") (or (imap-cst-list-list-conc-matchp cstss "dquote *quoted-char dquote"))))
Theorem:
(defthm imap-cst-quoted-char-concs (implies (imap-cst-list-list-alt-matchp cstss "<any TEXT-CHAR except quoted-specials> / \"\\\" quoted-specials") (or (imap-cst-list-list-conc-matchp cstss "<any TEXT-CHAR except quoted-specials>") (imap-cst-list-list-conc-matchp cstss "\"\\\" quoted-specials"))))
Theorem:
(defthm imap-cst-quoted-specials-concs (implies (imap-cst-list-list-alt-matchp cstss "dquote / \"\\\"") (or (imap-cst-list-list-conc-matchp cstss "dquote") (imap-cst-list-list-conc-matchp cstss "\"\\\""))))
Theorem:
(defthm imap-cst-rename-concs (implies (imap-cst-list-list-alt-matchp cstss "\"RENAME\" sp mailbox sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"RENAME\" sp mailbox sp mailbox"))))
Theorem:
(defthm imap-cst-response-concs (implies (imap-cst-list-list-alt-matchp cstss "*( continue-req / response-data ) response-done") (or (imap-cst-list-list-conc-matchp cstss "*( continue-req / response-data ) response-done"))))
Theorem:
(defthm imap-cst-response-data-concs (implies (imap-cst-list-list-alt-matchp cstss "\"*\" sp ( resp-cond-state / resp-cond-bye / mailbox-data / message-data / capability-data ) crlf") (or (imap-cst-list-list-conc-matchp cstss "\"*\" sp ( resp-cond-state / resp-cond-bye / mailbox-data / message-data / capability-data ) crlf"))))
Theorem:
(defthm imap-cst-response-done-concs (implies (imap-cst-list-list-alt-matchp cstss "response-tagged / response-fatal") (or (imap-cst-list-list-conc-matchp cstss "response-tagged") (imap-cst-list-list-conc-matchp cstss "response-fatal"))))
Theorem:
(defthm imap-cst-response-fatal-concs (implies (imap-cst-list-list-alt-matchp cstss "\"*\" sp resp-cond-bye crlf") (or (imap-cst-list-list-conc-matchp cstss "\"*\" sp resp-cond-bye crlf"))))
Theorem:
(defthm imap-cst-response-tagged-concs (implies (imap-cst-list-list-alt-matchp cstss "tag sp resp-cond-state crlf") (or (imap-cst-list-list-conc-matchp cstss "tag sp resp-cond-state crlf"))))
Theorem:
(defthm imap-cst-resp-cond-auth-concs (implies (imap-cst-list-list-alt-matchp cstss "( \"OK\" / \"PREAUTH\" ) sp resp-text") (or (imap-cst-list-list-conc-matchp cstss "( \"OK\" / \"PREAUTH\" ) sp resp-text"))))
Theorem:
(defthm imap-cst-resp-cond-bye-concs (implies (imap-cst-list-list-alt-matchp cstss "\"BYE\" sp resp-text") (or (imap-cst-list-list-conc-matchp cstss "\"BYE\" sp resp-text"))))
Theorem:
(defthm imap-cst-resp-cond-state-concs (implies (imap-cst-list-list-alt-matchp cstss "( \"OK\" / \"NO\" / \"BAD\" ) sp resp-text") (or (imap-cst-list-list-conc-matchp cstss "( \"OK\" / \"NO\" / \"BAD\" ) sp resp-text"))))
Theorem:
(defthm imap-cst-resp-specials-concs (implies (imap-cst-list-list-alt-matchp cstss "\"]\"") (or (imap-cst-list-list-conc-matchp cstss "\"]\""))))
Theorem:
(defthm imap-cst-resp-text-concs (implies (imap-cst-list-list-alt-matchp cstss "[ \"[\" resp-text-code \"]\" sp ] text") (or (imap-cst-list-list-conc-matchp cstss "[ \"[\" resp-text-code \"]\" sp ] text"))))
Theorem:
(defthm imap-cst-resp-text-code-concs (implies (imap-cst-list-list-alt-matchp cstss "\"ALERT\" / \"BADCHARSET\" [ sp \"(\" astring *( sp astring ) \")\" ] / capability-data / \"PARSE\" / \"PERMANENTFLAGS\" sp \"(\" [ flag-perm *( sp flag-perm ) ] \")\" / \"READ-ONLY\" / \"READ-WRITE\" / \"TRYCREATE\" / \"UIDNEXT\" sp nz-number / \"UIDVALIDITY\" sp nz-number / \"UNSEEN\" sp nz-number / atom [ sp 1*<any TEXT-CHAR except \"]\"> ]") (or (imap-cst-list-list-conc-matchp cstss "\"ALERT\"") (imap-cst-list-list-conc-matchp cstss "\"BADCHARSET\" [ sp \"(\" astring *( sp astring ) \")\" ]") (imap-cst-list-list-conc-matchp cstss "capability-data") (imap-cst-list-list-conc-matchp cstss "\"PARSE\"") (imap-cst-list-list-conc-matchp cstss "\"PERMANENTFLAGS\" sp \"(\" [ flag-perm *( sp flag-perm ) ] \")\"") (imap-cst-list-list-conc-matchp cstss "\"READ-ONLY\"") (imap-cst-list-list-conc-matchp cstss "\"READ-WRITE\"") (imap-cst-list-list-conc-matchp cstss "\"TRYCREATE\"") (imap-cst-list-list-conc-matchp cstss "\"UIDNEXT\" sp nz-number") (imap-cst-list-list-conc-matchp cstss "\"UIDVALIDITY\" sp nz-number") (imap-cst-list-list-conc-matchp cstss "\"UNSEEN\" sp nz-number") (imap-cst-list-list-conc-matchp cstss "atom [ sp 1*<any TEXT-CHAR except \"]\"> ]"))))
Theorem:
(defthm imap-cst-search-concs (implies (imap-cst-list-list-alt-matchp cstss "\"SEARCH\" [ sp \"CHARSET\" sp astring ] 1*( sp search-key )") (or (imap-cst-list-list-conc-matchp cstss "\"SEARCH\" [ sp \"CHARSET\" sp astring ] 1*( sp search-key )"))))
Theorem:
(defthm imap-cst-search-key-concs (implies (imap-cst-list-list-alt-matchp cstss "\"ALL\" / \"ANSWERED\" / \"BCC\" sp astring / \"BEFORE\" sp date / \"BODY\" sp astring / \"CC\" sp astring / \"DELETED\" / \"FLAGGED\" / \"FROM\" sp astring / \"KEYWORD\" sp flag-keyword / \"NEW\" / \"OLD\" / \"ON\" sp date / \"RECENT\" / \"SEEN\" / \"SINCE\" sp date / \"SUBJECT\" sp astring / \"TEXT\" sp astring / \"TO\" sp astring / \"UNANSWERED\" / \"UNDELETED\" / \"UNFLAGGED\" / \"UNKEYWORD\" sp flag-keyword / \"UNSEEN\" / \"DRAFT\" / \"HEADER\" sp header-fld-name sp astring / \"LARGER\" sp number / \"NOT\" sp search-key / \"OR\" sp search-key sp search-key / \"SENTBEFORE\" sp date / \"SENTON\" sp date / \"SENTSINCE\" sp date / \"SMALLER\" sp number / \"UID\" sp sequence-set / \"UNDRAFT\" / sequence-set / \"(\" search-key *( sp search-key ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"ALL\"") (imap-cst-list-list-conc-matchp cstss "\"ANSWERED\"") (imap-cst-list-list-conc-matchp cstss "\"BCC\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"BEFORE\" sp date") (imap-cst-list-list-conc-matchp cstss "\"BODY\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"CC\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"DELETED\"") (imap-cst-list-list-conc-matchp cstss "\"FLAGGED\"") (imap-cst-list-list-conc-matchp cstss "\"FROM\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"KEYWORD\" sp flag-keyword") (imap-cst-list-list-conc-matchp cstss "\"NEW\"") (imap-cst-list-list-conc-matchp cstss "\"OLD\"") (imap-cst-list-list-conc-matchp cstss "\"ON\" sp date") (imap-cst-list-list-conc-matchp cstss "\"RECENT\"") (imap-cst-list-list-conc-matchp cstss "\"SEEN\"") (imap-cst-list-list-conc-matchp cstss "\"SINCE\" sp date") (imap-cst-list-list-conc-matchp cstss "\"SUBJECT\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"TEXT\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"TO\" sp astring") (imap-cst-list-list-conc-matchp cstss "\"UNANSWERED\"") (imap-cst-list-list-conc-matchp cstss "\"UNDELETED\"") (imap-cst-list-list-conc-matchp cstss "\"UNFLAGGED\"") (imap-cst-list-list-conc-matchp cstss "\"UNKEYWORD\" sp flag-keyword") (imap-cst-list-list-conc-matchp cstss "\"UNSEEN\"") (imap-cst-list-list-conc-matchp cstss "\"DRAFT\"") (imap-cst-list-list-conc-matchp cstss "\"HEADER\" sp header-fld-name sp astring") (imap-cst-list-list-conc-matchp cstss "\"LARGER\" sp number") (imap-cst-list-list-conc-matchp cstss "\"NOT\" sp search-key") (imap-cst-list-list-conc-matchp cstss "\"OR\" sp search-key sp search-key") (imap-cst-list-list-conc-matchp cstss "\"SENTBEFORE\" sp date") (imap-cst-list-list-conc-matchp cstss "\"SENTON\" sp date") (imap-cst-list-list-conc-matchp cstss "\"SENTSINCE\" sp date") (imap-cst-list-list-conc-matchp cstss "\"SMALLER\" sp number") (imap-cst-list-list-conc-matchp cstss "\"UID\" sp sequence-set") (imap-cst-list-list-conc-matchp cstss "\"UNDRAFT\"") (imap-cst-list-list-conc-matchp cstss "sequence-set") (imap-cst-list-list-conc-matchp cstss "\"(\" search-key *( sp search-key ) \")\""))))
Theorem:
(defthm imap-cst-section-concs (implies (imap-cst-list-list-alt-matchp cstss "\"[\" [ section-spec ] \"]\"") (or (imap-cst-list-list-conc-matchp cstss "\"[\" [ section-spec ] \"]\""))))
Theorem:
(defthm imap-cst-section-msgtext-concs (implies (imap-cst-list-list-alt-matchp cstss "\"HEADER\" / \"HEADER.FIELDS\" [ \".NOT\" ] sp header-list / \"TEXT\"") (or (imap-cst-list-list-conc-matchp cstss "\"HEADER\"") (imap-cst-list-list-conc-matchp cstss "\"HEADER.FIELDS\" [ \".NOT\" ] sp header-list") (imap-cst-list-list-conc-matchp cstss "\"TEXT\""))))
Theorem:
(defthm imap-cst-section-part-concs (implies (imap-cst-list-list-alt-matchp cstss "nz-number *( \".\" nz-number )") (or (imap-cst-list-list-conc-matchp cstss "nz-number *( \".\" nz-number )"))))
Theorem:
(defthm imap-cst-section-spec-concs (implies (imap-cst-list-list-alt-matchp cstss "section-msgtext / ( section-part [ \".\" section-text ] )") (or (imap-cst-list-list-conc-matchp cstss "section-msgtext") (imap-cst-list-list-conc-matchp cstss "( section-part [ \".\" section-text ] )"))))
Theorem:
(defthm imap-cst-section-text-concs (implies (imap-cst-list-list-alt-matchp cstss "section-msgtext / \"MIME\"") (or (imap-cst-list-list-conc-matchp cstss "section-msgtext") (imap-cst-list-list-conc-matchp cstss "\"MIME\""))))
Theorem:
(defthm imap-cst-select-concs (implies (imap-cst-list-list-alt-matchp cstss "\"SELECT\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"SELECT\" sp mailbox"))))
Theorem:
(defthm imap-cst-seq-number-concs (implies (imap-cst-list-list-alt-matchp cstss "nz-number / \"*\"") (or (imap-cst-list-list-conc-matchp cstss "nz-number") (imap-cst-list-list-conc-matchp cstss "\"*\""))))
Theorem:
(defthm imap-cst-seq-range-concs (implies (imap-cst-list-list-alt-matchp cstss "seq-number \":\" seq-number") (or (imap-cst-list-list-conc-matchp cstss "seq-number \":\" seq-number"))))
Theorem:
(defthm imap-cst-sequence-set-concs (implies (imap-cst-list-list-alt-matchp cstss "( seq-number / seq-range ) *( \",\" sequence-set )") (or (imap-cst-list-list-conc-matchp cstss "( seq-number / seq-range ) *( \",\" sequence-set )"))))
Theorem:
(defthm imap-cst-status-concs (implies (imap-cst-list-list-alt-matchp cstss "\"STATUS\" sp mailbox sp \"(\" status-att *( sp status-att ) \")\"") (or (imap-cst-list-list-conc-matchp cstss "\"STATUS\" sp mailbox sp \"(\" status-att *( sp status-att ) \")\""))))
Theorem:
(defthm imap-cst-status-att-concs (implies (imap-cst-list-list-alt-matchp cstss "\"MESSAGES\" / \"RECENT\" / \"UIDNEXT\" / \"UIDVALIDITY\" / \"UNSEEN\"") (or (imap-cst-list-list-conc-matchp cstss "\"MESSAGES\"") (imap-cst-list-list-conc-matchp cstss "\"RECENT\"") (imap-cst-list-list-conc-matchp cstss "\"UIDNEXT\"") (imap-cst-list-list-conc-matchp cstss "\"UIDVALIDITY\"") (imap-cst-list-list-conc-matchp cstss "\"UNSEEN\""))))
Theorem:
(defthm imap-cst-status-att-list-concs (implies (imap-cst-list-list-alt-matchp cstss "status-att sp number *( sp status-att sp number )") (or (imap-cst-list-list-conc-matchp cstss "status-att sp number *( sp status-att sp number )"))))
Theorem:
(defthm imap-cst-store-concs (implies (imap-cst-list-list-alt-matchp cstss "\"STORE\" sp sequence-set sp store-att-flags") (or (imap-cst-list-list-conc-matchp cstss "\"STORE\" sp sequence-set sp store-att-flags"))))
Theorem:
(defthm imap-cst-store-att-flags-concs (implies (imap-cst-list-list-alt-matchp cstss "( [ \"+\" / \"-\" ] \"FLAGS\" [ \".SILENT\" ] ) sp ( flag-list / ( flag *( sp flag ) ) )") (or (imap-cst-list-list-conc-matchp cstss "( [ \"+\" / \"-\" ] \"FLAGS\" [ \".SILENT\" ] ) sp ( flag-list / ( flag *( sp flag ) ) )"))))
Theorem:
(defthm imap-cst-string-concs (implies (imap-cst-list-list-alt-matchp cstss "quoted / literal") (or (imap-cst-list-list-conc-matchp cstss "quoted") (imap-cst-list-list-conc-matchp cstss "literal"))))
Theorem:
(defthm imap-cst-subscribe-concs (implies (imap-cst-list-list-alt-matchp cstss "\"SUBSCRIBE\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"SUBSCRIBE\" sp mailbox"))))
Theorem:
(defthm imap-cst-tag-concs (implies (imap-cst-list-list-alt-matchp cstss "1*<any ASTRING-CHAR except \"+\">") (or (imap-cst-list-list-conc-matchp cstss "1*<any ASTRING-CHAR except \"+\">"))))
Theorem:
(defthm imap-cst-text-concs (implies (imap-cst-list-list-alt-matchp cstss "1*text-char") (or (imap-cst-list-list-conc-matchp cstss "1*text-char"))))
Theorem:
(defthm imap-cst-text-char-concs (implies (imap-cst-list-list-alt-matchp cstss "<any CHAR except CR and LF>") (or (imap-cst-list-list-conc-matchp cstss "<any CHAR except CR and LF>"))))
Theorem:
(defthm imap-cst-time-concs (implies (imap-cst-list-list-alt-matchp cstss "2digit \":\" 2digit \":\" 2digit") (or (imap-cst-list-list-conc-matchp cstss "2digit \":\" 2digit \":\" 2digit"))))
Theorem:
(defthm imap-cst-uid-concs (implies (imap-cst-list-list-alt-matchp cstss "\"UID\" sp ( copy / fetch / search / store )") (or (imap-cst-list-list-conc-matchp cstss "\"UID\" sp ( copy / fetch / search / store )"))))
Theorem:
(defthm imap-cst-uniqueid-concs (implies (imap-cst-list-list-alt-matchp cstss "nz-number") (or (imap-cst-list-list-conc-matchp cstss "nz-number"))))
Theorem:
(defthm imap-cst-unsubscribe-concs (implies (imap-cst-list-list-alt-matchp cstss "\"UNSUBSCRIBE\" sp mailbox") (or (imap-cst-list-list-conc-matchp cstss "\"UNSUBSCRIBE\" sp mailbox"))))
Theorem:
(defthm imap-cst-userid-concs (implies (imap-cst-list-list-alt-matchp cstss "astring") (or (imap-cst-list-list-conc-matchp cstss "astring"))))
Theorem:
(defthm imap-cst-x-command-concs (implies (imap-cst-list-list-alt-matchp cstss "\"X\" atom <experimental command arguments>") (or (imap-cst-list-list-conc-matchp cstss "\"X\" atom <experimental command arguments>"))))
Theorem:
(defthm imap-cst-zone-concs (implies (imap-cst-list-list-alt-matchp cstss "( \"+\" / \"-\" ) 4digit") (or (imap-cst-list-list-conc-matchp cstss "( \"+\" / \"-\" ) 4digit"))))
Theorem:
(defthm imap-cst-alpha-concs (implies (imap-cst-list-list-alt-matchp cstss "%x41-5A / %x61-7A") (or (imap-cst-list-list-conc-matchp cstss "%x41-5A") (imap-cst-list-list-conc-matchp cstss "%x61-7A"))))
Theorem:
(defthm imap-cst-crlf-concs (implies (imap-cst-list-list-alt-matchp cstss "cr lf") (or (imap-cst-list-list-conc-matchp cstss "cr lf"))))
Theorem:
(defthm imap-cst-cr-concs (implies (imap-cst-list-list-alt-matchp cstss "%xD") (or (imap-cst-list-list-conc-matchp cstss "%xD"))))
Theorem:
(defthm imap-cst-ctl-concs (implies (imap-cst-list-list-alt-matchp cstss "%x0-1F / %x7F") (or (imap-cst-list-list-conc-matchp cstss "%x0-1F") (imap-cst-list-list-conc-matchp cstss "%x7F"))))
Theorem:
(defthm imap-cst-digit-concs (implies (imap-cst-list-list-alt-matchp cstss "%x30-39") (or (imap-cst-list-list-conc-matchp cstss "%x30-39"))))
Theorem:
(defthm imap-cst-dquote-concs (implies (imap-cst-list-list-alt-matchp cstss "%x22") (or (imap-cst-list-list-conc-matchp cstss "%x22"))))
Theorem:
(defthm imap-cst-lf-concs (implies (imap-cst-list-list-alt-matchp cstss "%xA") (or (imap-cst-list-list-conc-matchp cstss "%xA"))))
Theorem:
(defthm imap-cst-sp-concs (implies (imap-cst-list-list-alt-matchp cstss "%x20") (or (imap-cst-list-list-conc-matchp cstss "%x20"))))
Theorem:
(defthm imap-cst-addr-adl-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-addr-host-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-addr-mailbox-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-addr-name-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-astring-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "1*astring-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*astring-char"))))
Theorem:
(defthm imap-cst-astring-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm imap-cst-astring-char-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "atom-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "atom-char"))))
Theorem:
(defthm imap-cst-astring-char-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "resp-specials") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "resp-specials"))))
Theorem:
(defthm imap-cst-atom-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "1*atom-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*atom-char"))))
Theorem:
(defthm imap-cst-atom-char-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "<any CHAR except atom-specials>") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "<any CHAR except atom-specials>"))))
Theorem:
(defthm imap-cst-atom-specials-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"(\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"(\""))))
Theorem:
(defthm imap-cst-atom-specials-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\")\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\")\""))))
Theorem:
(defthm imap-cst-atom-specials-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"{\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"{\""))))
Theorem:
(defthm imap-cst-atom-specials-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "sp") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "sp"))))
Theorem:
(defthm imap-cst-atom-specials-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "ctl") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "ctl"))))
Theorem:
(defthm imap-cst-atom-specials-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "list-wildcards") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "list-wildcards"))))
Theorem:
(defthm imap-cst-atom-specials-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "quoted-specials") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "quoted-specials"))))
Theorem:
(defthm imap-cst-atom-specials-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "resp-specials") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "resp-specials"))))
Theorem:
(defthm imap-cst-auth-type-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm imap-cst-base64-char-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm imap-cst-base64-char-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm imap-cst-base64-char-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"+\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"+\""))))
Theorem:
(defthm imap-cst-base64-char-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "\"/\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"/\""))))
Theorem:
(defthm imap-cst-base64-terminal-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "( 2base64-char \"==\" )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( 2base64-char \"==\" )"))))
Theorem:
(defthm imap-cst-base64-terminal-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "( 3base64-char \"=\" )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( 3base64-char \"=\" )"))))
Theorem:
(defthm imap-cst-body-extension-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-extension-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "number") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "number"))))
Theorem:
(defthm imap-cst-body-fld-desc-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-dsp-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-body-fld-enc-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote )"))))
Theorem:
(defthm imap-cst-body-fld-enc-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm imap-cst-body-fld-id-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lang-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-loc-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lines-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "number") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "number"))))
Theorem:
(defthm imap-cst-body-fld-md5-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-octets-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "number") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "number"))))
Theorem:
(defthm imap-cst-body-fld-param-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-capability-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "( \"AUTH=\" auth-type )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( \"AUTH=\" auth-type )"))))
Theorem:
(defthm imap-cst-capability-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm imap-cst-char8-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%x1-FF") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x1-FF"))))
Theorem:
(defthm imap-cst-command-any-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"CAPABILITY\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"CAPABILITY\""))))
Theorem:
(defthm imap-cst-command-any-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"LOGOUT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"LOGOUT\""))))
Theorem:
(defthm imap-cst-command-any-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"NOOP\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"NOOP\""))))
Theorem:
(defthm imap-cst-command-any-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "x-command") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "x-command"))))
Theorem:
(defthm imap-cst-command-auth-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "append") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "append"))))
Theorem:
(defthm imap-cst-command-auth-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "create") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "create"))))
Theorem:
(defthm imap-cst-command-auth-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "delete") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "delete"))))
Theorem:
(defthm imap-cst-command-auth-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "examine") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "examine"))))
Theorem:
(defthm imap-cst-command-auth-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "list") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "list"))))
Theorem:
(defthm imap-cst-command-auth-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "lsub") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "lsub"))))
Theorem:
(defthm imap-cst-command-auth-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "rename") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "rename"))))
Theorem:
(defthm imap-cst-command-auth-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "select") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "select"))))
Theorem:
(defthm imap-cst-command-auth-conc9-matching (implies (imap-cst-list-list-conc-matchp cstss "status") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "status"))))
Theorem:
(defthm imap-cst-command-auth-conc10-matching (implies (imap-cst-list-list-conc-matchp cstss "subscribe") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "subscribe"))))
Theorem:
(defthm imap-cst-command-auth-conc11-matching (implies (imap-cst-list-list-conc-matchp cstss "unsubscribe") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "unsubscribe"))))
Theorem:
(defthm imap-cst-command-nonauth-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "login") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "login"))))
Theorem:
(defthm imap-cst-command-nonauth-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "authenticate") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "authenticate"))))
Theorem:
(defthm imap-cst-command-nonauth-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"STARTTLS\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"STARTTLS\""))))
Theorem:
(defthm imap-cst-command-select-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"CHECK\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"CHECK\""))))
Theorem:
(defthm imap-cst-command-select-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"CLOSE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"CLOSE\""))))
Theorem:
(defthm imap-cst-command-select-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"EXPUNGE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"EXPUNGE\""))))
Theorem:
(defthm imap-cst-command-select-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "copy") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "copy"))))
Theorem:
(defthm imap-cst-command-select-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "fetch") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "fetch"))))
Theorem:
(defthm imap-cst-command-select-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "store") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "store"))))
Theorem:
(defthm imap-cst-command-select-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "uid") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "uid"))))
Theorem:
(defthm imap-cst-command-select-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "search") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "search"))))
Theorem:
(defthm imap-cst-date-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "date-text") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "date-text"))))
Theorem:
(defthm imap-cst-date-day-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "1*2digit") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*2digit"))))
Theorem:
(defthm imap-cst-date-day-fixed-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "( sp digit )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( sp digit )"))))
Theorem:
(defthm imap-cst-date-day-fixed-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "2digit") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "2digit"))))
Theorem:
(defthm imap-cst-date-month-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Jan\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Jan\""))))
Theorem:
(defthm imap-cst-date-month-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Feb\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Feb\""))))
Theorem:
(defthm imap-cst-date-month-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Mar\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Mar\""))))
Theorem:
(defthm imap-cst-date-month-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Apr\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Apr\""))))
Theorem:
(defthm imap-cst-date-month-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "\"May\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"May\""))))
Theorem:
(defthm imap-cst-date-month-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Jun\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Jun\""))))
Theorem:
(defthm imap-cst-date-month-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Jul\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Jul\""))))
Theorem:
(defthm imap-cst-date-month-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Aug\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Aug\""))))
Theorem:
(defthm imap-cst-date-month-conc9-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Sep\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Sep\""))))
Theorem:
(defthm imap-cst-date-month-conc10-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Oct\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Oct\""))))
Theorem:
(defthm imap-cst-date-month-conc11-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Nov\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Nov\""))))
Theorem:
(defthm imap-cst-date-month-conc12-matching (implies (imap-cst-list-list-conc-matchp cstss "\"Dec\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"Dec\""))))
Theorem:
(defthm imap-cst-date-year-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "4digit") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "4digit"))))
Theorem:
(defthm imap-cst-digit-nz-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%x31-39") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x31-39"))))
Theorem:
(defthm imap-cst-env-bcc-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-env-cc-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-env-date-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-env-from-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-env-in-reply-to-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-env-message-id-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-env-reply-to-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-env-sender-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-env-subject-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nstring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nstring"))))
Theorem:
(defthm imap-cst-env-to-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-fetch-att-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"ENVELOPE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"ENVELOPE\""))))
Theorem:
(defthm imap-cst-fetch-att-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"FLAGS\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"FLAGS\""))))
Theorem:
(defthm imap-cst-fetch-att-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"INTERNALDATE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"INTERNALDATE\""))))
Theorem:
(defthm imap-cst-fetch-att-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UID\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UID\""))))
Theorem:
(defthm imap-cst-flag-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Answered\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Answered\""))))
Theorem:
(defthm imap-cst-flag-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Flagged\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Flagged\""))))
Theorem:
(defthm imap-cst-flag-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Deleted\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Deleted\""))))
Theorem:
(defthm imap-cst-flag-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Seen\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Seen\""))))
Theorem:
(defthm imap-cst-flag-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Draft\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Draft\""))))
Theorem:
(defthm imap-cst-flag-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "flag-keyword") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "flag-keyword"))))
Theorem:
(defthm imap-cst-flag-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "flag-extension") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "flag-extension"))))
Theorem:
(defthm imap-cst-flag-fetch-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "flag") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "flag"))))
Theorem:
(defthm imap-cst-flag-fetch-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Recent\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Recent\""))))
Theorem:
(defthm imap-cst-flag-keyword-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "atom") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "atom"))))
Theorem:
(defthm imap-cst-flag-perm-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "flag") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "flag"))))
Theorem:
(defthm imap-cst-flag-perm-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\*\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\*\""))))
Theorem:
(defthm imap-cst-header-fld-name-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "astring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "astring"))))
Theorem:
(defthm imap-cst-list-mailbox-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "1*list-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*list-char"))))
Theorem:
(defthm imap-cst-list-mailbox-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm imap-cst-list-char-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "atom-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "atom-char"))))
Theorem:
(defthm imap-cst-list-char-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "list-wildcards") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "list-wildcards"))))
Theorem:
(defthm imap-cst-list-char-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "resp-specials") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "resp-specials"))))
Theorem:
(defthm imap-cst-list-wildcards-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"%\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"%\""))))
Theorem:
(defthm imap-cst-list-wildcards-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm imap-cst-mailbox-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"INBOX\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"INBOX\""))))
Theorem:
(defthm imap-cst-mailbox-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "astring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "astring"))))
Theorem:
(defthm imap-cst-mbx-list-oflag-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Noinferiors\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Noinferiors\""))))
Theorem:
(defthm imap-cst-mbx-list-oflag-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "flag-extension") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "flag-extension"))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Noselect\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Noselect\""))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Marked\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Marked\""))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\Unmarked\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\Unmarked\""))))
Theorem:
(defthm imap-cst-media-subtype-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm imap-cst-nil-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "\"NIL\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"NIL\""))))
Theorem:
(defthm imap-cst-nstring-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm imap-cst-nstring-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "nil") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nil"))))
Theorem:
(defthm imap-cst-number-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "1*digit") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*digit"))))
Theorem:
(defthm imap-cst-password-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "astring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "astring"))))
Theorem:
(defthm imap-cst-quoted-char-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "<any TEXT-CHAR except quoted-specials>") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "<any TEXT-CHAR except quoted-specials>"))))
Theorem:
(defthm imap-cst-quoted-specials-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "dquote") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "dquote"))))
Theorem:
(defthm imap-cst-quoted-specials-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"\\\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"\\\""))))
Theorem:
(defthm imap-cst-response-done-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "response-tagged") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "response-tagged"))))
Theorem:
(defthm imap-cst-response-done-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "response-fatal") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "response-fatal"))))
Theorem:
(defthm imap-cst-resp-specials-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "\"]\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"]\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"ALERT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"ALERT\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "capability-data") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "capability-data"))))
Theorem:
(defthm imap-cst-resp-text-code-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "\"PARSE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"PARSE\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc6-matching (implies (imap-cst-list-list-conc-matchp cstss "\"READ-ONLY\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"READ-ONLY\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "\"READ-WRITE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"READ-WRITE\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "\"TRYCREATE\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"TRYCREATE\""))))
Theorem:
(defthm imap-cst-search-key-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"ALL\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"ALL\""))))
Theorem:
(defthm imap-cst-search-key-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"ANSWERED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"ANSWERED\""))))
Theorem:
(defthm imap-cst-search-key-conc7-matching (implies (imap-cst-list-list-conc-matchp cstss "\"DELETED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"DELETED\""))))
Theorem:
(defthm imap-cst-search-key-conc8-matching (implies (imap-cst-list-list-conc-matchp cstss "\"FLAGGED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"FLAGGED\""))))
Theorem:
(defthm imap-cst-search-key-conc11-matching (implies (imap-cst-list-list-conc-matchp cstss "\"NEW\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"NEW\""))))
Theorem:
(defthm imap-cst-search-key-conc12-matching (implies (imap-cst-list-list-conc-matchp cstss "\"OLD\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"OLD\""))))
Theorem:
(defthm imap-cst-search-key-conc14-matching (implies (imap-cst-list-list-conc-matchp cstss "\"RECENT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"RECENT\""))))
Theorem:
(defthm imap-cst-search-key-conc15-matching (implies (imap-cst-list-list-conc-matchp cstss "\"SEEN\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"SEEN\""))))
Theorem:
(defthm imap-cst-search-key-conc20-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNANSWERED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNANSWERED\""))))
Theorem:
(defthm imap-cst-search-key-conc21-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNDELETED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNDELETED\""))))
Theorem:
(defthm imap-cst-search-key-conc22-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNFLAGGED\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNFLAGGED\""))))
Theorem:
(defthm imap-cst-search-key-conc24-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNSEEN\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNSEEN\""))))
Theorem:
(defthm imap-cst-search-key-conc25-matching (implies (imap-cst-list-list-conc-matchp cstss "\"DRAFT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"DRAFT\""))))
Theorem:
(defthm imap-cst-search-key-conc35-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNDRAFT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNDRAFT\""))))
Theorem:
(defthm imap-cst-search-key-conc36-matching (implies (imap-cst-list-list-conc-matchp cstss "sequence-set") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "sequence-set"))))
Theorem:
(defthm imap-cst-section-msgtext-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"HEADER\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"HEADER\""))))
Theorem:
(defthm imap-cst-section-msgtext-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"TEXT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"TEXT\""))))
Theorem:
(defthm imap-cst-section-spec-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "section-msgtext") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "section-msgtext"))))
Theorem:
(defthm imap-cst-section-spec-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "( section-part [ \".\" section-text ] )") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "( section-part [ \".\" section-text ] )"))))
Theorem:
(defthm imap-cst-section-text-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "section-msgtext") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "section-msgtext"))))
Theorem:
(defthm imap-cst-section-text-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"MIME\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"MIME\""))))
Theorem:
(defthm imap-cst-seq-number-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "nz-number") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nz-number"))))
Theorem:
(defthm imap-cst-seq-number-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm imap-cst-status-att-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "\"MESSAGES\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"MESSAGES\""))))
Theorem:
(defthm imap-cst-status-att-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "\"RECENT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"RECENT\""))))
Theorem:
(defthm imap-cst-status-att-conc3-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UIDNEXT\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UIDNEXT\""))))
Theorem:
(defthm imap-cst-status-att-conc4-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UIDVALIDITY\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UIDVALIDITY\""))))
Theorem:
(defthm imap-cst-status-att-conc5-matching (implies (imap-cst-list-list-conc-matchp cstss "\"UNSEEN\"") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "\"UNSEEN\""))))
Theorem:
(defthm imap-cst-string-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "quoted") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "quoted"))))
Theorem:
(defthm imap-cst-string-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "literal") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "literal"))))
Theorem:
(defthm imap-cst-tag-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "1*<any ASTRING-CHAR except \"+\">") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*<any ASTRING-CHAR except \"+\">"))))
Theorem:
(defthm imap-cst-text-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "1*text-char") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "1*text-char"))))
Theorem:
(defthm imap-cst-text-char-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "<any CHAR except CR and LF>") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "<any CHAR except CR and LF>"))))
Theorem:
(defthm imap-cst-uniqueid-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "nz-number") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "nz-number"))))
Theorem:
(defthm imap-cst-userid-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "astring") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "astring"))))
Theorem:
(defthm imap-cst-alpha-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "%x41-5A") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x41-5A"))))
Theorem:
(defthm imap-cst-alpha-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "%x61-7A") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x61-7A"))))
Theorem:
(defthm imap-cst-cr-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%xD") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%xD"))))
Theorem:
(defthm imap-cst-ctl-conc1-matching (implies (imap-cst-list-list-conc-matchp cstss "%x0-1F") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x0-1F"))))
Theorem:
(defthm imap-cst-ctl-conc2-matching (implies (imap-cst-list-list-conc-matchp cstss "%x7F") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x7F"))))
Theorem:
(defthm imap-cst-digit-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%x30-39") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x30-39"))))
Theorem:
(defthm imap-cst-dquote-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%x22") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x22"))))
Theorem:
(defthm imap-cst-lf-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%xA") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%xA"))))
Theorem:
(defthm imap-cst-sp-conc-matching (implies (imap-cst-list-list-conc-matchp cstss "%x20") (and (equal (len cstss) 1) (imap-cst-list-rep-matchp (nth 0 cstss) "%x20"))))
Theorem:
(defthm imap-cst-addr-adl-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-addr-host-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-addr-name-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-astring-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm imap-cst-astring-char-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "atom-char") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "atom-char"))))
Theorem:
(defthm imap-cst-astring-char-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "resp-specials") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "resp-specials"))))
Theorem:
(defthm imap-cst-atom-char-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "<any CHAR except atom-specials>") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "<any CHAR except atom-specials>"))))
Theorem:
(defthm imap-cst-atom-specials-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"(\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"(\""))))
Theorem:
(defthm imap-cst-atom-specials-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\")\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\")\""))))
Theorem:
(defthm imap-cst-atom-specials-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"{\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"{\""))))
Theorem:
(defthm imap-cst-atom-specials-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "sp") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "sp"))))
Theorem:
(defthm imap-cst-atom-specials-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "ctl") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "ctl"))))
Theorem:
(defthm imap-cst-atom-specials-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "list-wildcards") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "list-wildcards"))))
Theorem:
(defthm imap-cst-atom-specials-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "quoted-specials") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "quoted-specials"))))
Theorem:
(defthm imap-cst-atom-specials-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "resp-specials") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "resp-specials"))))
Theorem:
(defthm imap-cst-auth-type-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm imap-cst-base64-char-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm imap-cst-base64-char-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm imap-cst-base64-char-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"+\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"+\""))))
Theorem:
(defthm imap-cst-base64-char-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "\"/\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"/\""))))
Theorem:
(defthm imap-cst-base64-terminal-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "( 2base64-char \"==\" )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( 2base64-char \"==\" )"))))
Theorem:
(defthm imap-cst-base64-terminal-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "( 3base64-char \"=\" )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( 3base64-char \"=\" )"))))
Theorem:
(defthm imap-cst-body-extension-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-extension-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "number") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "number"))))
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-dsp-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-body-fld-enc-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( dquote ( \"7BIT\" / \"8BIT\" / \"BINARY\" / \"BASE64\" / \"QUOTED-PRINTABLE\" ) dquote )"))))
Theorem:
(defthm imap-cst-body-fld-enc-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lang-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "number") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "number"))))
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "number") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "number"))))
Theorem:
(defthm imap-cst-body-fld-param-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-capability-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "( \"AUTH=\" auth-type )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( \"AUTH=\" auth-type )"))))
Theorem:
(defthm imap-cst-capability-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm imap-cst-char8-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%x1-FF") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x1-FF"))))
Theorem:
(defthm imap-cst-command-any-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"CAPABILITY\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"CAPABILITY\""))))
Theorem:
(defthm imap-cst-command-any-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"LOGOUT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"LOGOUT\""))))
Theorem:
(defthm imap-cst-command-any-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"NOOP\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"NOOP\""))))
Theorem:
(defthm imap-cst-command-any-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "x-command") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "x-command"))))
Theorem:
(defthm imap-cst-command-auth-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "append") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "append"))))
Theorem:
(defthm imap-cst-command-auth-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "create") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "create"))))
Theorem:
(defthm imap-cst-command-auth-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "delete") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "delete"))))
Theorem:
(defthm imap-cst-command-auth-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "examine") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "examine"))))
Theorem:
(defthm imap-cst-command-auth-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "list") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "list"))))
Theorem:
(defthm imap-cst-command-auth-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "lsub") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "lsub"))))
Theorem:
(defthm imap-cst-command-auth-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "rename") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "rename"))))
Theorem:
(defthm imap-cst-command-auth-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "select") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "select"))))
Theorem:
(defthm imap-cst-command-auth-conc9-rep-matching (implies (imap-cst-list-rep-matchp csts "status") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "status"))))
Theorem:
(defthm imap-cst-command-auth-conc10-rep-matching (implies (imap-cst-list-rep-matchp csts "subscribe") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "subscribe"))))
Theorem:
(defthm imap-cst-command-auth-conc11-rep-matching (implies (imap-cst-list-rep-matchp csts "unsubscribe") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "unsubscribe"))))
Theorem:
(defthm imap-cst-command-nonauth-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "login") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "login"))))
Theorem:
(defthm imap-cst-command-nonauth-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "authenticate") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "authenticate"))))
Theorem:
(defthm imap-cst-command-nonauth-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"STARTTLS\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"STARTTLS\""))))
Theorem:
(defthm imap-cst-command-select-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"CHECK\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"CHECK\""))))
Theorem:
(defthm imap-cst-command-select-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"CLOSE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"CLOSE\""))))
Theorem:
(defthm imap-cst-command-select-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"EXPUNGE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"EXPUNGE\""))))
Theorem:
(defthm imap-cst-command-select-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "copy") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "copy"))))
Theorem:
(defthm imap-cst-command-select-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "fetch") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "fetch"))))
Theorem:
(defthm imap-cst-command-select-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "store") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "store"))))
Theorem:
(defthm imap-cst-command-select-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "uid") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "uid"))))
Theorem:
(defthm imap-cst-command-select-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "search") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "search"))))
Theorem:
(defthm imap-cst-date-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "date-text") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "date-text"))))
Theorem:
(defthm imap-cst-date-day-fixed-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "( sp digit )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( sp digit )"))))
Theorem:
(defthm imap-cst-date-month-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Jan\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Jan\""))))
Theorem:
(defthm imap-cst-date-month-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Feb\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Feb\""))))
Theorem:
(defthm imap-cst-date-month-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Mar\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Mar\""))))
Theorem:
(defthm imap-cst-date-month-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Apr\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Apr\""))))
Theorem:
(defthm imap-cst-date-month-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "\"May\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"May\""))))
Theorem:
(defthm imap-cst-date-month-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Jun\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Jun\""))))
Theorem:
(defthm imap-cst-date-month-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Jul\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Jul\""))))
Theorem:
(defthm imap-cst-date-month-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Aug\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Aug\""))))
Theorem:
(defthm imap-cst-date-month-conc9-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Sep\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Sep\""))))
Theorem:
(defthm imap-cst-date-month-conc10-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Oct\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Oct\""))))
Theorem:
(defthm imap-cst-date-month-conc11-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Nov\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Nov\""))))
Theorem:
(defthm imap-cst-date-month-conc12-rep-matching (implies (imap-cst-list-rep-matchp csts "\"Dec\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"Dec\""))))
Theorem:
(defthm imap-cst-digit-nz-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%x31-39") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x31-39"))))
Theorem:
(defthm imap-cst-env-bcc-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-env-cc-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-env-date-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-env-from-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-env-message-id-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-env-reply-to-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-env-sender-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-env-subject-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nstring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nstring"))))
Theorem:
(defthm imap-cst-env-to-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-fetch-att-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"ENVELOPE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"ENVELOPE\""))))
Theorem:
(defthm imap-cst-fetch-att-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"FLAGS\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"FLAGS\""))))
Theorem:
(defthm imap-cst-fetch-att-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"INTERNALDATE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"INTERNALDATE\""))))
Theorem:
(defthm imap-cst-fetch-att-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UID\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UID\""))))
Theorem:
(defthm imap-cst-flag-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Answered\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Answered\""))))
Theorem:
(defthm imap-cst-flag-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Flagged\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Flagged\""))))
Theorem:
(defthm imap-cst-flag-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Deleted\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Deleted\""))))
Theorem:
(defthm imap-cst-flag-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Seen\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Seen\""))))
Theorem:
(defthm imap-cst-flag-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Draft\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Draft\""))))
Theorem:
(defthm imap-cst-flag-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "flag-keyword") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "flag-keyword"))))
Theorem:
(defthm imap-cst-flag-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "flag-extension") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "flag-extension"))))
Theorem:
(defthm imap-cst-flag-fetch-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "flag") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "flag"))))
Theorem:
(defthm imap-cst-flag-fetch-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Recent\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Recent\""))))
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "atom") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "atom"))))
Theorem:
(defthm imap-cst-flag-perm-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "flag") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "flag"))))
Theorem:
(defthm imap-cst-flag-perm-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\*\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\*\""))))
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "astring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "astring"))))
Theorem:
(defthm imap-cst-list-mailbox-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm imap-cst-list-char-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "atom-char") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "atom-char"))))
Theorem:
(defthm imap-cst-list-char-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "list-wildcards") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "list-wildcards"))))
Theorem:
(defthm imap-cst-list-char-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "resp-specials") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "resp-specials"))))
Theorem:
(defthm imap-cst-list-wildcards-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"%\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"%\""))))
Theorem:
(defthm imap-cst-list-wildcards-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm imap-cst-mailbox-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"INBOX\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"INBOX\""))))
Theorem:
(defthm imap-cst-mailbox-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "astring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "astring"))))
Theorem:
(defthm imap-cst-mbx-list-oflag-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Noinferiors\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Noinferiors\""))))
Theorem:
(defthm imap-cst-mbx-list-oflag-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "flag-extension") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "flag-extension"))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Noselect\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Noselect\""))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Marked\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Marked\""))))
Theorem:
(defthm imap-cst-mbx-list-sflag-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\Unmarked\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\Unmarked\""))))
Theorem:
(defthm imap-cst-media-subtype-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm imap-cst-nil-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "\"NIL\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"NIL\""))))
Theorem:
(defthm imap-cst-nstring-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm imap-cst-nstring-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "nil") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nil"))))
Theorem:
(defthm imap-cst-password-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "astring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "astring"))))
Theorem:
(defthm imap-cst-quoted-char-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "<any TEXT-CHAR except quoted-specials>") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "<any TEXT-CHAR except quoted-specials>"))))
Theorem:
(defthm imap-cst-quoted-specials-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "dquote") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "dquote"))))
Theorem:
(defthm imap-cst-quoted-specials-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"\\\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"\\\""))))
Theorem:
(defthm imap-cst-response-done-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "response-tagged") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "response-tagged"))))
Theorem:
(defthm imap-cst-response-done-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "response-fatal") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "response-fatal"))))
Theorem:
(defthm imap-cst-resp-specials-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "\"]\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"]\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"ALERT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"ALERT\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "capability-data") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "capability-data"))))
Theorem:
(defthm imap-cst-resp-text-code-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "\"PARSE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"PARSE\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc6-rep-matching (implies (imap-cst-list-rep-matchp csts "\"READ-ONLY\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"READ-ONLY\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "\"READ-WRITE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"READ-WRITE\""))))
Theorem:
(defthm imap-cst-resp-text-code-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "\"TRYCREATE\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"TRYCREATE\""))))
Theorem:
(defthm imap-cst-search-key-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"ALL\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"ALL\""))))
Theorem:
(defthm imap-cst-search-key-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"ANSWERED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"ANSWERED\""))))
Theorem:
(defthm imap-cst-search-key-conc7-rep-matching (implies (imap-cst-list-rep-matchp csts "\"DELETED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"DELETED\""))))
Theorem:
(defthm imap-cst-search-key-conc8-rep-matching (implies (imap-cst-list-rep-matchp csts "\"FLAGGED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"FLAGGED\""))))
Theorem:
(defthm imap-cst-search-key-conc11-rep-matching (implies (imap-cst-list-rep-matchp csts "\"NEW\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"NEW\""))))
Theorem:
(defthm imap-cst-search-key-conc12-rep-matching (implies (imap-cst-list-rep-matchp csts "\"OLD\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"OLD\""))))
Theorem:
(defthm imap-cst-search-key-conc14-rep-matching (implies (imap-cst-list-rep-matchp csts "\"RECENT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"RECENT\""))))
Theorem:
(defthm imap-cst-search-key-conc15-rep-matching (implies (imap-cst-list-rep-matchp csts "\"SEEN\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"SEEN\""))))
Theorem:
(defthm imap-cst-search-key-conc20-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNANSWERED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNANSWERED\""))))
Theorem:
(defthm imap-cst-search-key-conc21-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNDELETED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNDELETED\""))))
Theorem:
(defthm imap-cst-search-key-conc22-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNFLAGGED\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNFLAGGED\""))))
Theorem:
(defthm imap-cst-search-key-conc24-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNSEEN\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNSEEN\""))))
Theorem:
(defthm imap-cst-search-key-conc25-rep-matching (implies (imap-cst-list-rep-matchp csts "\"DRAFT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"DRAFT\""))))
Theorem:
(defthm imap-cst-search-key-conc35-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNDRAFT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNDRAFT\""))))
Theorem:
(defthm imap-cst-search-key-conc36-rep-matching (implies (imap-cst-list-rep-matchp csts "sequence-set") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "sequence-set"))))
Theorem:
(defthm imap-cst-section-msgtext-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"HEADER\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"HEADER\""))))
Theorem:
(defthm imap-cst-section-msgtext-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"TEXT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"TEXT\""))))
Theorem:
(defthm imap-cst-section-spec-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "section-msgtext") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "section-msgtext"))))
Theorem:
(defthm imap-cst-section-spec-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "( section-part [ \".\" section-text ] )") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "( section-part [ \".\" section-text ] )"))))
Theorem:
(defthm imap-cst-section-text-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "section-msgtext") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "section-msgtext"))))
Theorem:
(defthm imap-cst-section-text-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"MIME\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"MIME\""))))
Theorem:
(defthm imap-cst-seq-number-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "nz-number") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nz-number"))))
Theorem:
(defthm imap-cst-seq-number-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm imap-cst-status-att-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "\"MESSAGES\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"MESSAGES\""))))
Theorem:
(defthm imap-cst-status-att-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "\"RECENT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"RECENT\""))))
Theorem:
(defthm imap-cst-status-att-conc3-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UIDNEXT\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UIDNEXT\""))))
Theorem:
(defthm imap-cst-status-att-conc4-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UIDVALIDITY\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UIDVALIDITY\""))))
Theorem:
(defthm imap-cst-status-att-conc5-rep-matching (implies (imap-cst-list-rep-matchp csts "\"UNSEEN\"") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "\"UNSEEN\""))))
Theorem:
(defthm imap-cst-string-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "quoted") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "quoted"))))
Theorem:
(defthm imap-cst-string-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "literal") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "literal"))))
Theorem:
(defthm imap-cst-text-char-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "<any CHAR except CR and LF>") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "<any CHAR except CR and LF>"))))
Theorem:
(defthm imap-cst-uniqueid-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "nz-number") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "nz-number"))))
Theorem:
(defthm imap-cst-userid-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "astring") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "astring"))))
Theorem:
(defthm imap-cst-alpha-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "%x41-5A") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x41-5A"))))
Theorem:
(defthm imap-cst-alpha-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "%x61-7A") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x61-7A"))))
Theorem:
(defthm imap-cst-cr-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%xD") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%xD"))))
Theorem:
(defthm imap-cst-ctl-conc1-rep-matching (implies (imap-cst-list-rep-matchp csts "%x0-1F") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x0-1F"))))
Theorem:
(defthm imap-cst-ctl-conc2-rep-matching (implies (imap-cst-list-rep-matchp csts "%x7F") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x7F"))))
Theorem:
(defthm imap-cst-digit-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%x30-39") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x30-39"))))
Theorem:
(defthm imap-cst-dquote-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%x22") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x22"))))
Theorem:
(defthm imap-cst-lf-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%xA") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%xA"))))
Theorem:
(defthm imap-cst-sp-conc-rep-matching (implies (imap-cst-list-rep-matchp csts "%x20") (and (equal (len csts) 1) (imap-cst-matchp (nth 0 csts) "%x20"))))
Theorem:
(defthm imap-cst-astring-char-conc-equivs (implies (imap-cst-matchp cst "astring-char") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom-char") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom-char"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "resp-specials") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "resp-specials"))))))
Theorem:
(defthm imap-cst-command-auth-conc-equivs (implies (imap-cst-matchp cst "command-auth") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "append") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "append"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "create") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "create"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "delete") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "delete"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "examine") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "examine"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "list") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "list"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "lsub") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "lsub"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rename") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rename"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "select") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "select"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "status") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "status"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "subscribe") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "subscribe"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "unsubscribe") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "unsubscribe"))))))
Theorem:
(defthm imap-cst-flag-fetch-conc-equivs (implies (imap-cst-matchp cst "flag-fetch") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "flag") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"\\Recent\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm imap-cst-flag-perm-conc-equivs (implies (imap-cst-matchp cst "flag-perm") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "flag") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"\\*\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm imap-cst-list-char-conc-equivs (implies (imap-cst-matchp cst "list-char") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom-char") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom-char"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "list-wildcards") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "list-wildcards"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "resp-specials") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "resp-specials"))))))
Theorem:
(defthm imap-cst-mailbox-conc-equivs (implies (imap-cst-matchp cst "mailbox") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"INBOX\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "astring") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)))))
Theorem:
(defthm imap-cst-mbx-list-oflag-conc-equivs (implies (imap-cst-matchp cst "mbx-list-oflag") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"\\Noinferiors\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "flag-extension") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)))))
Theorem:
(defthm imap-cst-nstring-conc-equivs (implies (imap-cst-matchp cst "nstring") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "string"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "nil") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "nil"))))))
Theorem:
(defthm imap-cst-quoted-specials-conc-equivs (implies (imap-cst-matchp cst "quoted-specials") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dquote") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"\\\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm imap-cst-response-done-conc-equivs (implies (imap-cst-matchp cst "response-done") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "response-tagged") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "response-tagged"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "response-fatal") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "response-fatal"))))))
Theorem:
(defthm imap-cst-section-text-conc-equivs (implies (imap-cst-matchp cst "section-text") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "section-msgtext") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"MIME\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm imap-cst-seq-number-conc-equivs (implies (imap-cst-matchp cst "seq-number") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "nz-number") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :nonleaf)) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "\"*\"") (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst))) :leafterm)))))
Theorem:
(defthm imap-cst-string-conc-equivs (implies (imap-cst-matchp cst "string") (and (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted"))) (iff (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "literal") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "literal"))))))
Function:
(defun imap-cst-astring-char-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "astring-char"))) (let ((__function__ 'imap-cst-astring-char-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom-char")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "resp-specials")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-astring-char-conc? (b* ((number (imap-cst-astring-char-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc?-possibilities (b* ((number (imap-cst-astring-char-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-astring-char-conc? cst)))))
Theorem:
(defthm imap-cst-astring-char-conc?-of-tree-fix-cst (equal (imap-cst-astring-char-conc? (tree-fix cst)) (imap-cst-astring-char-conc? cst)))
Theorem:
(defthm imap-cst-astring-char-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc? cst) (imap-cst-astring-char-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-astring-char-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "astring-char") (iff (equal (imap-cst-astring-char-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom-char"))))
Theorem:
(defthm imap-cst-astring-char-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "astring-char") (iff (equal (imap-cst-astring-char-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "resp-specials"))))
Function:
(defun imap-cst-command-auth-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "command-auth"))) (let ((__function__ 'imap-cst-command-auth-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "append")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "create")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "delete")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "examine")) 4) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "list")) 5) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "lsub")) 6) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rename")) 7) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "select")) 8) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "status")) 9) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "subscribe")) 10) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "unsubscribe")) 11) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-command-auth-conc? (b* ((number (imap-cst-command-auth-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc?-possibilities (b* ((number (imap-cst-command-auth-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6) (equal number 7) (equal number 8) (equal number 9) (equal number 10) (equal number 11))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-command-auth-conc? cst)))))
Theorem:
(defthm imap-cst-command-auth-conc?-of-tree-fix-cst (equal (imap-cst-command-auth-conc? (tree-fix cst)) (imap-cst-command-auth-conc? cst)))
Theorem:
(defthm imap-cst-command-auth-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc? cst) (imap-cst-command-auth-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-command-auth-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "append"))))
Theorem:
(defthm imap-cst-command-auth-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "create"))))
Theorem:
(defthm imap-cst-command-auth-conc?-3-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 3) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "delete"))))
Theorem:
(defthm imap-cst-command-auth-conc?-4-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 4) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "examine"))))
Theorem:
(defthm imap-cst-command-auth-conc?-5-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 5) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "list"))))
Theorem:
(defthm imap-cst-command-auth-conc?-6-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 6) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "lsub"))))
Theorem:
(defthm imap-cst-command-auth-conc?-7-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 7) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rename"))))
Theorem:
(defthm imap-cst-command-auth-conc?-8-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 8) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "select"))))
Theorem:
(defthm imap-cst-command-auth-conc?-9-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 9) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "status"))))
Theorem:
(defthm imap-cst-command-auth-conc?-10-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 10) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "subscribe"))))
Theorem:
(defthm imap-cst-command-auth-conc?-11-iff-match-conc (implies (imap-cst-matchp cst "command-auth") (iff (equal (imap-cst-command-auth-conc? cst) 11) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "unsubscribe"))))
Function:
(defun imap-cst-list-char-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "list-char"))) (let ((__function__ 'imap-cst-list-char-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "atom-char")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "list-wildcards")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "resp-specials")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-list-char-conc? (b* ((number (imap-cst-list-char-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc?-possibilities (b* ((number (imap-cst-list-char-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-list-char-conc? cst)))))
Theorem:
(defthm imap-cst-list-char-conc?-of-tree-fix-cst (equal (imap-cst-list-char-conc? (tree-fix cst)) (imap-cst-list-char-conc? cst)))
Theorem:
(defthm imap-cst-list-char-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc? cst) (imap-cst-list-char-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-list-char-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "list-char") (iff (equal (imap-cst-list-char-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "atom-char"))))
Theorem:
(defthm imap-cst-list-char-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "list-char") (iff (equal (imap-cst-list-char-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "list-wildcards"))))
Theorem:
(defthm imap-cst-list-char-conc?-3-iff-match-conc (implies (imap-cst-matchp cst "list-char") (iff (equal (imap-cst-list-char-conc? cst) 3) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "resp-specials"))))
Function:
(defun imap-cst-nstring-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "nstring"))) (let ((__function__ 'imap-cst-nstring-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "string")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "nil")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-nstring-conc? (b* ((number (imap-cst-nstring-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc?-possibilities (b* ((number (imap-cst-nstring-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-nstring-conc? cst)))))
Theorem:
(defthm imap-cst-nstring-conc?-of-tree-fix-cst (equal (imap-cst-nstring-conc? (tree-fix cst)) (imap-cst-nstring-conc? cst)))
Theorem:
(defthm imap-cst-nstring-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc? cst) (imap-cst-nstring-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-nstring-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "nstring") (iff (equal (imap-cst-nstring-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "string"))))
Theorem:
(defthm imap-cst-nstring-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "nstring") (iff (equal (imap-cst-nstring-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "nil"))))
Function:
(defun imap-cst-response-done-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "response-done"))) (let ((__function__ 'imap-cst-response-done-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "response-tagged")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "response-fatal")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-response-done-conc? (b* ((number (imap-cst-response-done-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc?-possibilities (b* ((number (imap-cst-response-done-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-response-done-conc? cst)))))
Theorem:
(defthm imap-cst-response-done-conc?-of-tree-fix-cst (equal (imap-cst-response-done-conc? (tree-fix cst)) (imap-cst-response-done-conc? cst)))
Theorem:
(defthm imap-cst-response-done-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc? cst) (imap-cst-response-done-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-response-done-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "response-done") (iff (equal (imap-cst-response-done-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "response-tagged"))))
Theorem:
(defthm imap-cst-response-done-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "response-done") (iff (equal (imap-cst-response-done-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "response-fatal"))))
Function:
(defun imap-cst-string-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "string"))) (let ((__function__ 'imap-cst-string-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "literal")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-imap-cst-string-conc? (b* ((number (imap-cst-string-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc?-possibilities (b* ((number (imap-cst-string-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((imap-cst-string-conc? cst)))))
Theorem:
(defthm imap-cst-string-conc?-of-tree-fix-cst (equal (imap-cst-string-conc? (tree-fix cst)) (imap-cst-string-conc? cst)))
Theorem:
(defthm imap-cst-string-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc? cst) (imap-cst-string-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm imap-cst-string-conc?-1-iff-match-conc (implies (imap-cst-matchp cst "string") (iff (equal (imap-cst-string-conc? cst) 1) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted"))))
Theorem:
(defthm imap-cst-string-conc?-2-iff-match-conc (implies (imap-cst-matchp cst "string") (iff (equal (imap-cst-string-conc? cst) 2) (imap-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "literal"))))
Function:
(defun imap-cst-address-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "address"))) (let ((__function__ 'imap-cst-address-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-address-conc (b* ((cstss (imap-cst-address-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-address-conc-match (implies (imap-cst-matchp cst "address") (b* ((cstss (imap-cst-address-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" addr-name sp addr-adl sp addr-mailbox sp addr-host \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-address-conc-of-tree-fix-cst (equal (imap-cst-address-conc (tree-fix cst)) (imap-cst-address-conc cst)))
Theorem:
(defthm imap-cst-address-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-address-conc cst) (imap-cst-address-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-adl-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-adl"))) (let ((__function__ 'imap-cst-addr-adl-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-addr-adl-conc (b* ((cstss (imap-cst-addr-adl-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-match (implies (imap-cst-matchp cst "addr-adl") (b* ((cstss (imap-cst-addr-adl-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-of-tree-fix-cst (equal (imap-cst-addr-adl-conc (tree-fix cst)) (imap-cst-addr-adl-conc cst)))
Theorem:
(defthm imap-cst-addr-adl-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-adl-conc cst) (imap-cst-addr-adl-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-host-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-host"))) (let ((__function__ 'imap-cst-addr-host-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-addr-host-conc (b* ((cstss (imap-cst-addr-host-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-match (implies (imap-cst-matchp cst "addr-host") (b* ((cstss (imap-cst-addr-host-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-of-tree-fix-cst (equal (imap-cst-addr-host-conc (tree-fix cst)) (imap-cst-addr-host-conc cst)))
Theorem:
(defthm imap-cst-addr-host-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-host-conc cst) (imap-cst-addr-host-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-mailbox-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-mailbox"))) (let ((__function__ 'imap-cst-addr-mailbox-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-addr-mailbox-conc (b* ((cstss (imap-cst-addr-mailbox-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-match (implies (imap-cst-matchp cst "addr-mailbox") (b* ((cstss (imap-cst-addr-mailbox-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-of-tree-fix-cst (equal (imap-cst-addr-mailbox-conc (tree-fix cst)) (imap-cst-addr-mailbox-conc cst)))
Theorem:
(defthm imap-cst-addr-mailbox-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-mailbox-conc cst) (imap-cst-addr-mailbox-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-name"))) (let ((__function__ 'imap-cst-addr-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-addr-name-conc (b* ((cstss (imap-cst-addr-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-match (implies (imap-cst-matchp cst "addr-name") (b* ((cstss (imap-cst-addr-name-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-of-tree-fix-cst (equal (imap-cst-addr-name-conc (tree-fix cst)) (imap-cst-addr-name-conc cst)))
Theorem:
(defthm imap-cst-addr-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-name-conc cst) (imap-cst-addr-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-append-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "append"))) (let ((__function__ 'imap-cst-append-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-append-conc (b* ((cstss (imap-cst-append-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-append-conc-match (implies (imap-cst-matchp cst "append") (b* ((cstss (imap-cst-append-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"APPEND\" sp mailbox [ sp flag-list ] [ sp date-time ] sp literal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-append-conc-of-tree-fix-cst (equal (imap-cst-append-conc (tree-fix cst)) (imap-cst-append-conc cst)))
Theorem:
(defthm imap-cst-append-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-append-conc cst) (imap-cst-append-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-astring-char-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-astring-char-conc1 (b* ((cstss (imap-cst-astring-char-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)) (b* ((cstss (imap-cst-astring-char-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-of-tree-fix-cst (equal (imap-cst-astring-char-conc1 (tree-fix cst)) (imap-cst-astring-char-conc1 cst)))
Theorem:
(defthm imap-cst-astring-char-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc1 cst) (imap-cst-astring-char-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-astring-char-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-astring-char-conc2 (b* ((cstss (imap-cst-astring-char-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)) (b* ((cstss (imap-cst-astring-char-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-of-tree-fix-cst (equal (imap-cst-astring-char-conc2 (tree-fix cst)) (imap-cst-astring-char-conc2 cst)))
Theorem:
(defthm imap-cst-astring-char-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc2 cst) (imap-cst-astring-char-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-atom-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "atom"))) (let ((__function__ 'imap-cst-atom-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-atom-conc (b* ((cstss (imap-cst-atom-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-conc-match (implies (imap-cst-matchp cst "atom") (b* ((cstss (imap-cst-atom-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-conc-of-tree-fix-cst (equal (imap-cst-atom-conc (tree-fix cst)) (imap-cst-atom-conc cst)))
Theorem:
(defthm imap-cst-atom-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-atom-conc cst) (imap-cst-atom-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-atom-char-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "atom-char"))) (let ((__function__ 'imap-cst-atom-char-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-atom-char-conc (b* ((cstss (imap-cst-atom-char-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-match (implies (imap-cst-matchp cst "atom-char") (b* ((cstss (imap-cst-atom-char-conc cst))) (imap-cst-list-list-conc-matchp cstss "<any CHAR except atom-specials>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-of-tree-fix-cst (equal (imap-cst-atom-char-conc (tree-fix cst)) (imap-cst-atom-char-conc cst)))
Theorem:
(defthm imap-cst-atom-char-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-atom-char-conc cst) (imap-cst-atom-char-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-authenticate-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "authenticate"))) (let ((__function__ 'imap-cst-authenticate-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-authenticate-conc (b* ((cstss (imap-cst-authenticate-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-authenticate-conc-match (implies (imap-cst-matchp cst "authenticate") (b* ((cstss (imap-cst-authenticate-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"AUTHENTICATE\" sp auth-type *( crlf base64 )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-authenticate-conc-of-tree-fix-cst (equal (imap-cst-authenticate-conc (tree-fix cst)) (imap-cst-authenticate-conc cst)))
Theorem:
(defthm imap-cst-authenticate-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-authenticate-conc cst) (imap-cst-authenticate-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-auth-type-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "auth-type"))) (let ((__function__ 'imap-cst-auth-type-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-auth-type-conc (b* ((cstss (imap-cst-auth-type-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-match (implies (imap-cst-matchp cst "auth-type") (b* ((cstss (imap-cst-auth-type-conc cst))) (imap-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-of-tree-fix-cst (equal (imap-cst-auth-type-conc (tree-fix cst)) (imap-cst-auth-type-conc cst)))
Theorem:
(defthm imap-cst-auth-type-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-auth-type-conc cst) (imap-cst-auth-type-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-base64-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "base64"))) (let ((__function__ 'imap-cst-base64-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-base64-conc (b* ((cstss (imap-cst-base64-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-base64-conc-match (implies (imap-cst-matchp cst "base64") (b* ((cstss (imap-cst-base64-conc cst))) (imap-cst-list-list-conc-matchp cstss "*( 4base64-char ) [ base64-terminal ]"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-base64-conc-of-tree-fix-cst (equal (imap-cst-base64-conc (tree-fix cst)) (imap-cst-base64-conc cst)))
Theorem:
(defthm imap-cst-base64-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-base64-conc cst) (imap-cst-base64-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body"))) (let ((__function__ 'imap-cst-body-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-conc (b* ((cstss (imap-cst-body-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-conc-match (implies (imap-cst-matchp cst "body") (b* ((cstss (imap-cst-body-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" ( body-type-1part / body-type-mpart ) \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-conc-of-tree-fix-cst (equal (imap-cst-body-conc (tree-fix cst)) (imap-cst-body-conc cst)))
Theorem:
(defthm imap-cst-body-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-conc cst) (imap-cst-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-ext-1part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-ext-1part"))) (let ((__function__ 'imap-cst-body-ext-1part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-ext-1part-conc (b* ((cstss (imap-cst-body-ext-1part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-ext-1part-conc-match (implies (imap-cst-matchp cst "body-ext-1part") (b* ((cstss (imap-cst-body-ext-1part-conc cst))) (imap-cst-list-list-conc-matchp cstss "body-fld-md5 [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-ext-1part-conc-of-tree-fix-cst (equal (imap-cst-body-ext-1part-conc (tree-fix cst)) (imap-cst-body-ext-1part-conc cst)))
Theorem:
(defthm imap-cst-body-ext-1part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-ext-1part-conc cst) (imap-cst-body-ext-1part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-ext-mpart-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-ext-mpart"))) (let ((__function__ 'imap-cst-body-ext-mpart-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-ext-mpart-conc (b* ((cstss (imap-cst-body-ext-mpart-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-ext-mpart-conc-match (implies (imap-cst-matchp cst "body-ext-mpart") (b* ((cstss (imap-cst-body-ext-mpart-conc cst))) (imap-cst-list-list-conc-matchp cstss "body-fld-param [ sp body-fld-dsp [ sp body-fld-lang [ sp body-fld-loc *( sp body-extension ) ] ] ]"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-ext-mpart-conc-of-tree-fix-cst (equal (imap-cst-body-ext-mpart-conc (tree-fix cst)) (imap-cst-body-ext-mpart-conc cst)))
Theorem:
(defthm imap-cst-body-ext-mpart-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-ext-mpart-conc cst) (imap-cst-body-ext-mpart-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fields-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fields"))) (let ((__function__ 'imap-cst-body-fields-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fields-conc (b* ((cstss (imap-cst-body-fields-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fields-conc-match (implies (imap-cst-matchp cst "body-fields") (b* ((cstss (imap-cst-body-fields-conc cst))) (imap-cst-list-list-conc-matchp cstss "body-fld-param sp body-fld-id sp body-fld-desc sp body-fld-enc sp body-fld-octets"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fields-conc-of-tree-fix-cst (equal (imap-cst-body-fields-conc (tree-fix cst)) (imap-cst-body-fields-conc cst)))
Theorem:
(defthm imap-cst-body-fields-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fields-conc cst) (imap-cst-body-fields-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-desc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-desc"))) (let ((__function__ 'imap-cst-body-fld-desc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-desc-conc (b* ((cstss (imap-cst-body-fld-desc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-match (implies (imap-cst-matchp cst "body-fld-desc") (b* ((cstss (imap-cst-body-fld-desc-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-of-tree-fix-cst (equal (imap-cst-body-fld-desc-conc (tree-fix cst)) (imap-cst-body-fld-desc-conc cst)))
Theorem:
(defthm imap-cst-body-fld-desc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-desc-conc cst) (imap-cst-body-fld-desc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-id"))) (let ((__function__ 'imap-cst-body-fld-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-id-conc (b* ((cstss (imap-cst-body-fld-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-match (implies (imap-cst-matchp cst "body-fld-id") (b* ((cstss (imap-cst-body-fld-id-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-of-tree-fix-cst (equal (imap-cst-body-fld-id-conc (tree-fix cst)) (imap-cst-body-fld-id-conc cst)))
Theorem:
(defthm imap-cst-body-fld-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-id-conc cst) (imap-cst-body-fld-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-loc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-loc"))) (let ((__function__ 'imap-cst-body-fld-loc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-loc-conc (b* ((cstss (imap-cst-body-fld-loc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-match (implies (imap-cst-matchp cst "body-fld-loc") (b* ((cstss (imap-cst-body-fld-loc-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-of-tree-fix-cst (equal (imap-cst-body-fld-loc-conc (tree-fix cst)) (imap-cst-body-fld-loc-conc cst)))
Theorem:
(defthm imap-cst-body-fld-loc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-loc-conc cst) (imap-cst-body-fld-loc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-lines-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-lines"))) (let ((__function__ 'imap-cst-body-fld-lines-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-lines-conc (b* ((cstss (imap-cst-body-fld-lines-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-match (implies (imap-cst-matchp cst "body-fld-lines") (b* ((cstss (imap-cst-body-fld-lines-conc cst))) (imap-cst-list-list-conc-matchp cstss "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-of-tree-fix-cst (equal (imap-cst-body-fld-lines-conc (tree-fix cst)) (imap-cst-body-fld-lines-conc cst)))
Theorem:
(defthm imap-cst-body-fld-lines-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-lines-conc cst) (imap-cst-body-fld-lines-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-md5-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-md5"))) (let ((__function__ 'imap-cst-body-fld-md5-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-md5-conc (b* ((cstss (imap-cst-body-fld-md5-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-match (implies (imap-cst-matchp cst "body-fld-md5") (b* ((cstss (imap-cst-body-fld-md5-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-of-tree-fix-cst (equal (imap-cst-body-fld-md5-conc (tree-fix cst)) (imap-cst-body-fld-md5-conc cst)))
Theorem:
(defthm imap-cst-body-fld-md5-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-md5-conc cst) (imap-cst-body-fld-md5-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-octets-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-octets"))) (let ((__function__ 'imap-cst-body-fld-octets-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-fld-octets-conc (b* ((cstss (imap-cst-body-fld-octets-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-match (implies (imap-cst-matchp cst "body-fld-octets") (b* ((cstss (imap-cst-body-fld-octets-conc cst))) (imap-cst-list-list-conc-matchp cstss "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-of-tree-fix-cst (equal (imap-cst-body-fld-octets-conc (tree-fix cst)) (imap-cst-body-fld-octets-conc cst)))
Theorem:
(defthm imap-cst-body-fld-octets-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-octets-conc cst) (imap-cst-body-fld-octets-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-type-1part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-type-1part"))) (let ((__function__ 'imap-cst-body-type-1part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-type-1part-conc (b* ((cstss (imap-cst-body-type-1part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-1part-conc-match (implies (imap-cst-matchp cst "body-type-1part") (b* ((cstss (imap-cst-body-type-1part-conc cst))) (imap-cst-list-list-conc-matchp cstss "( body-type-basic / body-type-msg / body-type-text ) [ sp body-ext-1part ]"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-1part-conc-of-tree-fix-cst (equal (imap-cst-body-type-1part-conc (tree-fix cst)) (imap-cst-body-type-1part-conc cst)))
Theorem:
(defthm imap-cst-body-type-1part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-type-1part-conc cst) (imap-cst-body-type-1part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-type-basic-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-type-basic"))) (let ((__function__ 'imap-cst-body-type-basic-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-type-basic-conc (b* ((cstss (imap-cst-body-type-basic-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-basic-conc-match (implies (imap-cst-matchp cst "body-type-basic") (b* ((cstss (imap-cst-body-type-basic-conc cst))) (imap-cst-list-list-conc-matchp cstss "media-basic sp body-fields"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-basic-conc-of-tree-fix-cst (equal (imap-cst-body-type-basic-conc (tree-fix cst)) (imap-cst-body-type-basic-conc cst)))
Theorem:
(defthm imap-cst-body-type-basic-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-type-basic-conc cst) (imap-cst-body-type-basic-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-type-mpart-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-type-mpart"))) (let ((__function__ 'imap-cst-body-type-mpart-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-type-mpart-conc (b* ((cstss (imap-cst-body-type-mpart-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-mpart-conc-match (implies (imap-cst-matchp cst "body-type-mpart") (b* ((cstss (imap-cst-body-type-mpart-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*body sp media-subtype [ sp body-ext-mpart ]"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-mpart-conc-of-tree-fix-cst (equal (imap-cst-body-type-mpart-conc (tree-fix cst)) (imap-cst-body-type-mpart-conc cst)))
Theorem:
(defthm imap-cst-body-type-mpart-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-type-mpart-conc cst) (imap-cst-body-type-mpart-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-type-msg-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-type-msg"))) (let ((__function__ 'imap-cst-body-type-msg-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-type-msg-conc (b* ((cstss (imap-cst-body-type-msg-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-msg-conc-match (implies (imap-cst-matchp cst "body-type-msg") (b* ((cstss (imap-cst-body-type-msg-conc cst))) (imap-cst-list-list-conc-matchp cstss "media-message sp body-fields sp envelope sp body sp body-fld-lines"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-msg-conc-of-tree-fix-cst (equal (imap-cst-body-type-msg-conc (tree-fix cst)) (imap-cst-body-type-msg-conc cst)))
Theorem:
(defthm imap-cst-body-type-msg-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-type-msg-conc cst) (imap-cst-body-type-msg-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-type-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-type-text"))) (let ((__function__ 'imap-cst-body-type-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-body-type-text-conc (b* ((cstss (imap-cst-body-type-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-text-conc-match (implies (imap-cst-matchp cst "body-type-text") (b* ((cstss (imap-cst-body-type-text-conc cst))) (imap-cst-list-list-conc-matchp cstss "media-text sp body-fields sp body-fld-lines"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-type-text-conc-of-tree-fix-cst (equal (imap-cst-body-type-text-conc (tree-fix cst)) (imap-cst-body-type-text-conc cst)))
Theorem:
(defthm imap-cst-body-type-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-type-text-conc cst) (imap-cst-body-type-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-capability-data-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "capability-data"))) (let ((__function__ 'imap-cst-capability-data-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-capability-data-conc (b* ((cstss (imap-cst-capability-data-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-capability-data-conc-match (implies (imap-cst-matchp cst "capability-data") (b* ((cstss (imap-cst-capability-data-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"CAPABILITY\" *( sp capability ) sp \"IMAP4rev1\" *( sp capability )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-capability-data-conc-of-tree-fix-cst (equal (imap-cst-capability-data-conc (tree-fix cst)) (imap-cst-capability-data-conc cst)))
Theorem:
(defthm imap-cst-capability-data-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-capability-data-conc cst) (imap-cst-capability-data-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-char8-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "char8"))) (let ((__function__ 'imap-cst-char8-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-char8-conc (b* ((cstss (imap-cst-char8-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-match (implies (imap-cst-matchp cst "char8") (b* ((cstss (imap-cst-char8-conc cst))) (imap-cst-list-list-conc-matchp cstss "%x1-FF"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-of-tree-fix-cst (equal (imap-cst-char8-conc (tree-fix cst)) (imap-cst-char8-conc cst)))
Theorem:
(defthm imap-cst-char8-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-char8-conc cst) (imap-cst-char8-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "command"))) (let ((__function__ 'imap-cst-command-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-conc (b* ((cstss (imap-cst-command-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-conc-match (implies (imap-cst-matchp cst "command") (b* ((cstss (imap-cst-command-conc cst))) (imap-cst-list-list-conc-matchp cstss "tag sp ( command-any / command-auth / command-nonauth / command-select ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-conc-of-tree-fix-cst (equal (imap-cst-command-conc (tree-fix cst)) (imap-cst-command-conc cst)))
Theorem:
(defthm imap-cst-command-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-conc cst) (imap-cst-command-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)))) (let ((__function__ 'imap-cst-command-auth-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc1 (b* ((cstss (imap-cst-command-auth-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)) (b* ((cstss (imap-cst-command-auth-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "append"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-of-tree-fix-cst (equal (imap-cst-command-auth-conc1 (tree-fix cst)) (imap-cst-command-auth-conc1 cst)))
Theorem:
(defthm imap-cst-command-auth-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc1 cst) (imap-cst-command-auth-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)))) (let ((__function__ 'imap-cst-command-auth-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc2 (b* ((cstss (imap-cst-command-auth-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)) (b* ((cstss (imap-cst-command-auth-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "create"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-of-tree-fix-cst (equal (imap-cst-command-auth-conc2 (tree-fix cst)) (imap-cst-command-auth-conc2 cst)))
Theorem:
(defthm imap-cst-command-auth-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc2 cst) (imap-cst-command-auth-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)))) (let ((__function__ 'imap-cst-command-auth-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc3 (b* ((cstss (imap-cst-command-auth-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)) (b* ((cstss (imap-cst-command-auth-conc3 cst))) (imap-cst-list-list-conc-matchp cstss "delete"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-of-tree-fix-cst (equal (imap-cst-command-auth-conc3 (tree-fix cst)) (imap-cst-command-auth-conc3 cst)))
Theorem:
(defthm imap-cst-command-auth-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc3 cst) (imap-cst-command-auth-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)))) (let ((__function__ 'imap-cst-command-auth-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc4 (b* ((cstss (imap-cst-command-auth-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)) (b* ((cstss (imap-cst-command-auth-conc4 cst))) (imap-cst-list-list-conc-matchp cstss "examine"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-of-tree-fix-cst (equal (imap-cst-command-auth-conc4 (tree-fix cst)) (imap-cst-command-auth-conc4 cst)))
Theorem:
(defthm imap-cst-command-auth-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc4 cst) (imap-cst-command-auth-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc5 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)))) (let ((__function__ 'imap-cst-command-auth-conc5)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc5 (b* ((cstss (imap-cst-command-auth-conc5 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)) (b* ((cstss (imap-cst-command-auth-conc5 cst))) (imap-cst-list-list-conc-matchp cstss "list"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-of-tree-fix-cst (equal (imap-cst-command-auth-conc5 (tree-fix cst)) (imap-cst-command-auth-conc5 cst)))
Theorem:
(defthm imap-cst-command-auth-conc5-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc5 cst) (imap-cst-command-auth-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc6 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)))) (let ((__function__ 'imap-cst-command-auth-conc6)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc6 (b* ((cstss (imap-cst-command-auth-conc6 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)) (b* ((cstss (imap-cst-command-auth-conc6 cst))) (imap-cst-list-list-conc-matchp cstss "lsub"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-of-tree-fix-cst (equal (imap-cst-command-auth-conc6 (tree-fix cst)) (imap-cst-command-auth-conc6 cst)))
Theorem:
(defthm imap-cst-command-auth-conc6-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc6 cst) (imap-cst-command-auth-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc7 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)))) (let ((__function__ 'imap-cst-command-auth-conc7)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc7 (b* ((cstss (imap-cst-command-auth-conc7 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)) (b* ((cstss (imap-cst-command-auth-conc7 cst))) (imap-cst-list-list-conc-matchp cstss "rename"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-of-tree-fix-cst (equal (imap-cst-command-auth-conc7 (tree-fix cst)) (imap-cst-command-auth-conc7 cst)))
Theorem:
(defthm imap-cst-command-auth-conc7-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc7 cst) (imap-cst-command-auth-conc7 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc8 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)))) (let ((__function__ 'imap-cst-command-auth-conc8)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc8 (b* ((cstss (imap-cst-command-auth-conc8 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)) (b* ((cstss (imap-cst-command-auth-conc8 cst))) (imap-cst-list-list-conc-matchp cstss "select"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-of-tree-fix-cst (equal (imap-cst-command-auth-conc8 (tree-fix cst)) (imap-cst-command-auth-conc8 cst)))
Theorem:
(defthm imap-cst-command-auth-conc8-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc8 cst) (imap-cst-command-auth-conc8 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc9 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)))) (let ((__function__ 'imap-cst-command-auth-conc9)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc9 (b* ((cstss (imap-cst-command-auth-conc9 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)) (b* ((cstss (imap-cst-command-auth-conc9 cst))) (imap-cst-list-list-conc-matchp cstss "status"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-of-tree-fix-cst (equal (imap-cst-command-auth-conc9 (tree-fix cst)) (imap-cst-command-auth-conc9 cst)))
Theorem:
(defthm imap-cst-command-auth-conc9-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc9 cst) (imap-cst-command-auth-conc9 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc10 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)))) (let ((__function__ 'imap-cst-command-auth-conc10)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc10 (b* ((cstss (imap-cst-command-auth-conc10 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)) (b* ((cstss (imap-cst-command-auth-conc10 cst))) (imap-cst-list-list-conc-matchp cstss "subscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-of-tree-fix-cst (equal (imap-cst-command-auth-conc10 (tree-fix cst)) (imap-cst-command-auth-conc10 cst)))
Theorem:
(defthm imap-cst-command-auth-conc10-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc10 cst) (imap-cst-command-auth-conc10 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc11 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)))) (let ((__function__ 'imap-cst-command-auth-conc11)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-command-auth-conc11 (b* ((cstss (imap-cst-command-auth-conc11 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)) (b* ((cstss (imap-cst-command-auth-conc11 cst))) (imap-cst-list-list-conc-matchp cstss "unsubscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-of-tree-fix-cst (equal (imap-cst-command-auth-conc11 (tree-fix cst)) (imap-cst-command-auth-conc11 cst)))
Theorem:
(defthm imap-cst-command-auth-conc11-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc11 cst) (imap-cst-command-auth-conc11 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-continue-req-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "continue-req"))) (let ((__function__ 'imap-cst-continue-req-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-continue-req-conc (b* ((cstss (imap-cst-continue-req-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-continue-req-conc-match (implies (imap-cst-matchp cst "continue-req") (b* ((cstss (imap-cst-continue-req-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"+\" sp ( resp-text / base64 ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-continue-req-conc-of-tree-fix-cst (equal (imap-cst-continue-req-conc (tree-fix cst)) (imap-cst-continue-req-conc cst)))
Theorem:
(defthm imap-cst-continue-req-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-continue-req-conc cst) (imap-cst-continue-req-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-copy-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "copy"))) (let ((__function__ 'imap-cst-copy-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-copy-conc (b* ((cstss (imap-cst-copy-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-copy-conc-match (implies (imap-cst-matchp cst "copy") (b* ((cstss (imap-cst-copy-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"COPY\" sp sequence-set sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-copy-conc-of-tree-fix-cst (equal (imap-cst-copy-conc (tree-fix cst)) (imap-cst-copy-conc cst)))
Theorem:
(defthm imap-cst-copy-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-copy-conc cst) (imap-cst-copy-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-create-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "create"))) (let ((__function__ 'imap-cst-create-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-create-conc (b* ((cstss (imap-cst-create-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-create-conc-match (implies (imap-cst-matchp cst "create") (b* ((cstss (imap-cst-create-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"CREATE\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-create-conc-of-tree-fix-cst (equal (imap-cst-create-conc (tree-fix cst)) (imap-cst-create-conc cst)))
Theorem:
(defthm imap-cst-create-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-create-conc cst) (imap-cst-create-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-date-day-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "date-day"))) (let ((__function__ 'imap-cst-date-day-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-date-day-conc (b* ((cstss (imap-cst-date-day-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-day-conc-match (implies (imap-cst-matchp cst "date-day") (b* ((cstss (imap-cst-date-day-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*2digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-day-conc-of-tree-fix-cst (equal (imap-cst-date-day-conc (tree-fix cst)) (imap-cst-date-day-conc cst)))
Theorem:
(defthm imap-cst-date-day-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-date-day-conc cst) (imap-cst-date-day-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-date-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "date-text"))) (let ((__function__ 'imap-cst-date-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-date-text-conc (b* ((cstss (imap-cst-date-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-text-conc-match (implies (imap-cst-matchp cst "date-text") (b* ((cstss (imap-cst-date-text-conc cst))) (imap-cst-list-list-conc-matchp cstss "date-day \"-\" date-month \"-\" date-year"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-text-conc-of-tree-fix-cst (equal (imap-cst-date-text-conc (tree-fix cst)) (imap-cst-date-text-conc cst)))
Theorem:
(defthm imap-cst-date-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-date-text-conc cst) (imap-cst-date-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-date-year-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "date-year"))) (let ((__function__ 'imap-cst-date-year-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-date-year-conc (b* ((cstss (imap-cst-date-year-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-year-conc-match (implies (imap-cst-matchp cst "date-year") (b* ((cstss (imap-cst-date-year-conc cst))) (imap-cst-list-list-conc-matchp cstss "4digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-year-conc-of-tree-fix-cst (equal (imap-cst-date-year-conc (tree-fix cst)) (imap-cst-date-year-conc cst)))
Theorem:
(defthm imap-cst-date-year-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-date-year-conc cst) (imap-cst-date-year-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-date-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "date-time"))) (let ((__function__ 'imap-cst-date-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-date-time-conc (b* ((cstss (imap-cst-date-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-time-conc-match (implies (imap-cst-matchp cst "date-time") (b* ((cstss (imap-cst-date-time-conc cst))) (imap-cst-list-list-conc-matchp cstss "dquote date-day-fixed \"-\" date-month \"-\" date-year sp time sp zone dquote"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-date-time-conc-of-tree-fix-cst (equal (imap-cst-date-time-conc (tree-fix cst)) (imap-cst-date-time-conc cst)))
Theorem:
(defthm imap-cst-date-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-date-time-conc cst) (imap-cst-date-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-delete-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "delete"))) (let ((__function__ 'imap-cst-delete-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-delete-conc (b* ((cstss (imap-cst-delete-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-delete-conc-match (implies (imap-cst-matchp cst "delete") (b* ((cstss (imap-cst-delete-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"DELETE\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-delete-conc-of-tree-fix-cst (equal (imap-cst-delete-conc (tree-fix cst)) (imap-cst-delete-conc cst)))
Theorem:
(defthm imap-cst-delete-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-delete-conc cst) (imap-cst-delete-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-nz-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit-nz"))) (let ((__function__ 'imap-cst-digit-nz-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-digit-nz-conc (b* ((cstss (imap-cst-digit-nz-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-match (implies (imap-cst-matchp cst "digit-nz") (b* ((cstss (imap-cst-digit-nz-conc cst))) (imap-cst-list-list-conc-matchp cstss "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-of-tree-fix-cst (equal (imap-cst-digit-nz-conc (tree-fix cst)) (imap-cst-digit-nz-conc cst)))
Theorem:
(defthm imap-cst-digit-nz-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-nz-conc cst) (imap-cst-digit-nz-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-envelope-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "envelope"))) (let ((__function__ 'imap-cst-envelope-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-envelope-conc (b* ((cstss (imap-cst-envelope-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-envelope-conc-match (implies (imap-cst-matchp cst "envelope") (b* ((cstss (imap-cst-envelope-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" env-date sp env-subject sp env-from sp env-sender sp env-reply-to sp env-to sp env-cc sp env-bcc sp env-in-reply-to sp env-message-id \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-envelope-conc-of-tree-fix-cst (equal (imap-cst-envelope-conc (tree-fix cst)) (imap-cst-envelope-conc cst)))
Theorem:
(defthm imap-cst-envelope-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-envelope-conc cst) (imap-cst-envelope-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-date-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-date"))) (let ((__function__ 'imap-cst-env-date-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-env-date-conc (b* ((cstss (imap-cst-env-date-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-match (implies (imap-cst-matchp cst "env-date") (b* ((cstss (imap-cst-env-date-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-of-tree-fix-cst (equal (imap-cst-env-date-conc (tree-fix cst)) (imap-cst-env-date-conc cst)))
Theorem:
(defthm imap-cst-env-date-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-date-conc cst) (imap-cst-env-date-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-in-reply-to-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-in-reply-to"))) (let ((__function__ 'imap-cst-env-in-reply-to-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-env-in-reply-to-conc (b* ((cstss (imap-cst-env-in-reply-to-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-match (implies (imap-cst-matchp cst "env-in-reply-to") (b* ((cstss (imap-cst-env-in-reply-to-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-of-tree-fix-cst (equal (imap-cst-env-in-reply-to-conc (tree-fix cst)) (imap-cst-env-in-reply-to-conc cst)))
Theorem:
(defthm imap-cst-env-in-reply-to-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-in-reply-to-conc cst) (imap-cst-env-in-reply-to-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-message-id-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-message-id"))) (let ((__function__ 'imap-cst-env-message-id-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-env-message-id-conc (b* ((cstss (imap-cst-env-message-id-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-match (implies (imap-cst-matchp cst "env-message-id") (b* ((cstss (imap-cst-env-message-id-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-of-tree-fix-cst (equal (imap-cst-env-message-id-conc (tree-fix cst)) (imap-cst-env-message-id-conc cst)))
Theorem:
(defthm imap-cst-env-message-id-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-message-id-conc cst) (imap-cst-env-message-id-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-subject-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-subject"))) (let ((__function__ 'imap-cst-env-subject-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-env-subject-conc (b* ((cstss (imap-cst-env-subject-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-match (implies (imap-cst-matchp cst "env-subject") (b* ((cstss (imap-cst-env-subject-conc cst))) (imap-cst-list-list-conc-matchp cstss "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-of-tree-fix-cst (equal (imap-cst-env-subject-conc (tree-fix cst)) (imap-cst-env-subject-conc cst)))
Theorem:
(defthm imap-cst-env-subject-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-subject-conc cst) (imap-cst-env-subject-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-examine-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "examine"))) (let ((__function__ 'imap-cst-examine-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-examine-conc (b* ((cstss (imap-cst-examine-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-examine-conc-match (implies (imap-cst-matchp cst "examine") (b* ((cstss (imap-cst-examine-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"EXAMINE\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-examine-conc-of-tree-fix-cst (equal (imap-cst-examine-conc (tree-fix cst)) (imap-cst-examine-conc cst)))
Theorem:
(defthm imap-cst-examine-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-examine-conc cst) (imap-cst-examine-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-fetch-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "fetch"))) (let ((__function__ 'imap-cst-fetch-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-fetch-conc (b* ((cstss (imap-cst-fetch-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-fetch-conc-match (implies (imap-cst-matchp cst "fetch") (b* ((cstss (imap-cst-fetch-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"FETCH\" sp sequence-set sp ( \"ALL\" / \"FULL\" / \"FAST\" / fetch-att / \"(\" fetch-att *( sp fetch-att ) \")\" )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-fetch-conc-of-tree-fix-cst (equal (imap-cst-fetch-conc (tree-fix cst)) (imap-cst-fetch-conc cst)))
Theorem:
(defthm imap-cst-fetch-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-fetch-conc cst) (imap-cst-fetch-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-flag-extension-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "flag-extension"))) (let ((__function__ 'imap-cst-flag-extension-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-flag-extension-conc (b* ((cstss (imap-cst-flag-extension-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-extension-conc-match (implies (imap-cst-matchp cst "flag-extension") (b* ((cstss (imap-cst-flag-extension-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"\\\" atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-extension-conc-of-tree-fix-cst (equal (imap-cst-flag-extension-conc (tree-fix cst)) (imap-cst-flag-extension-conc cst)))
Theorem:
(defthm imap-cst-flag-extension-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-flag-extension-conc cst) (imap-cst-flag-extension-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-flag-keyword-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "flag-keyword"))) (let ((__function__ 'imap-cst-flag-keyword-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-flag-keyword-conc (b* ((cstss (imap-cst-flag-keyword-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-match (implies (imap-cst-matchp cst "flag-keyword") (b* ((cstss (imap-cst-flag-keyword-conc cst))) (imap-cst-list-list-conc-matchp cstss "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-of-tree-fix-cst (equal (imap-cst-flag-keyword-conc (tree-fix cst)) (imap-cst-flag-keyword-conc cst)))
Theorem:
(defthm imap-cst-flag-keyword-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-flag-keyword-conc cst) (imap-cst-flag-keyword-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-flag-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "flag-list"))) (let ((__function__ 'imap-cst-flag-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-flag-list-conc (b* ((cstss (imap-cst-flag-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-list-conc-match (implies (imap-cst-matchp cst "flag-list") (b* ((cstss (imap-cst-flag-list-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" [ flag *( sp flag ) ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-list-conc-of-tree-fix-cst (equal (imap-cst-flag-list-conc (tree-fix cst)) (imap-cst-flag-list-conc cst)))
Theorem:
(defthm imap-cst-flag-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-flag-list-conc cst) (imap-cst-flag-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-greeting-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "greeting"))) (let ((__function__ 'imap-cst-greeting-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-greeting-conc (b* ((cstss (imap-cst-greeting-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-greeting-conc-match (implies (imap-cst-matchp cst "greeting") (b* ((cstss (imap-cst-greeting-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"*\" sp ( resp-cond-auth / resp-cond-bye ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-greeting-conc-of-tree-fix-cst (equal (imap-cst-greeting-conc (tree-fix cst)) (imap-cst-greeting-conc cst)))
Theorem:
(defthm imap-cst-greeting-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-greeting-conc cst) (imap-cst-greeting-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-header-fld-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "header-fld-name"))) (let ((__function__ 'imap-cst-header-fld-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-header-fld-name-conc (b* ((cstss (imap-cst-header-fld-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-match (implies (imap-cst-matchp cst "header-fld-name") (b* ((cstss (imap-cst-header-fld-name-conc cst))) (imap-cst-list-list-conc-matchp cstss "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-of-tree-fix-cst (equal (imap-cst-header-fld-name-conc (tree-fix cst)) (imap-cst-header-fld-name-conc cst)))
Theorem:
(defthm imap-cst-header-fld-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-header-fld-name-conc cst) (imap-cst-header-fld-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-header-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "header-list"))) (let ((__function__ 'imap-cst-header-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-header-list-conc (b* ((cstss (imap-cst-header-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-list-conc-match (implies (imap-cst-matchp cst "header-list") (b* ((cstss (imap-cst-header-list-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" header-fld-name *( sp header-fld-name ) \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-list-conc-of-tree-fix-cst (equal (imap-cst-header-list-conc (tree-fix cst)) (imap-cst-header-list-conc cst)))
Theorem:
(defthm imap-cst-header-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-header-list-conc cst) (imap-cst-header-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "list"))) (let ((__function__ 'imap-cst-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-list-conc (b* ((cstss (imap-cst-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-conc-match (implies (imap-cst-matchp cst "list") (b* ((cstss (imap-cst-list-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"LIST\" sp mailbox sp list-mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-conc-of-tree-fix-cst (equal (imap-cst-list-conc (tree-fix cst)) (imap-cst-list-conc cst)))
Theorem:
(defthm imap-cst-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-conc cst) (imap-cst-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-list-char-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-list-char-conc1 (b* ((cstss (imap-cst-list-char-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)) (b* ((cstss (imap-cst-list-char-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-of-tree-fix-cst (equal (imap-cst-list-char-conc1 (tree-fix cst)) (imap-cst-list-char-conc1 cst)))
Theorem:
(defthm imap-cst-list-char-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc1 cst) (imap-cst-list-char-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-list-char-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-list-char-conc2 (b* ((cstss (imap-cst-list-char-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)) (b* ((cstss (imap-cst-list-char-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "list-wildcards"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-of-tree-fix-cst (equal (imap-cst-list-char-conc2 (tree-fix cst)) (imap-cst-list-char-conc2 cst)))
Theorem:
(defthm imap-cst-list-char-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc2 cst) (imap-cst-list-char-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)))) (let ((__function__ 'imap-cst-list-char-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-list-char-conc3 (b* ((cstss (imap-cst-list-char-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)) (b* ((cstss (imap-cst-list-char-conc3 cst))) (imap-cst-list-list-conc-matchp cstss "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-of-tree-fix-cst (equal (imap-cst-list-char-conc3 (tree-fix cst)) (imap-cst-list-char-conc3 cst)))
Theorem:
(defthm imap-cst-list-char-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc3 cst) (imap-cst-list-char-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "literal"))) (let ((__function__ 'imap-cst-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-literal-conc (b* ((cstss (imap-cst-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-literal-conc-match (implies (imap-cst-matchp cst "literal") (b* ((cstss (imap-cst-literal-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"{\" number \"}\" crlf *char8"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-literal-conc-of-tree-fix-cst (equal (imap-cst-literal-conc (tree-fix cst)) (imap-cst-literal-conc cst)))
Theorem:
(defthm imap-cst-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-literal-conc cst) (imap-cst-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-login-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "login"))) (let ((__function__ 'imap-cst-login-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-login-conc (b* ((cstss (imap-cst-login-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-login-conc-match (implies (imap-cst-matchp cst "login") (b* ((cstss (imap-cst-login-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"LOGIN\" sp userid sp password"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-login-conc-of-tree-fix-cst (equal (imap-cst-login-conc (tree-fix cst)) (imap-cst-login-conc cst)))
Theorem:
(defthm imap-cst-login-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-login-conc cst) (imap-cst-login-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-lsub-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "lsub"))) (let ((__function__ 'imap-cst-lsub-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-lsub-conc (b* ((cstss (imap-cst-lsub-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lsub-conc-match (implies (imap-cst-matchp cst "lsub") (b* ((cstss (imap-cst-lsub-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"LSUB\" sp mailbox sp list-mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lsub-conc-of-tree-fix-cst (equal (imap-cst-lsub-conc (tree-fix cst)) (imap-cst-lsub-conc cst)))
Theorem:
(defthm imap-cst-lsub-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-lsub-conc cst) (imap-cst-lsub-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-mailbox-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "mailbox-list"))) (let ((__function__ 'imap-cst-mailbox-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-mailbox-list-conc (b* ((cstss (imap-cst-mailbox-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-mailbox-list-conc-match (implies (imap-cst-matchp cst "mailbox-list") (b* ((cstss (imap-cst-mailbox-list-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" [ mbx-list-flags ] \")\" sp ( dquote quoted-char dquote / nil ) sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-mailbox-list-conc-of-tree-fix-cst (equal (imap-cst-mailbox-list-conc (tree-fix cst)) (imap-cst-mailbox-list-conc cst)))
Theorem:
(defthm imap-cst-mailbox-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-mailbox-list-conc cst) (imap-cst-mailbox-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-basic-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-basic"))) (let ((__function__ 'imap-cst-media-basic-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-media-basic-conc (b* ((cstss (imap-cst-media-basic-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-basic-conc-match (implies (imap-cst-matchp cst "media-basic") (b* ((cstss (imap-cst-media-basic-conc cst))) (imap-cst-list-list-conc-matchp cstss "( ( dquote ( \"APPLICATION\" / \"AUDIO\" / \"IMAGE\" / \"MESSAGE\" / \"VIDEO\" ) dquote ) / string ) sp media-subtype"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-basic-conc-of-tree-fix-cst (equal (imap-cst-media-basic-conc (tree-fix cst)) (imap-cst-media-basic-conc cst)))
Theorem:
(defthm imap-cst-media-basic-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-basic-conc cst) (imap-cst-media-basic-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-message-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-message"))) (let ((__function__ 'imap-cst-media-message-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-media-message-conc (b* ((cstss (imap-cst-media-message-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-message-conc-match (implies (imap-cst-matchp cst "media-message") (b* ((cstss (imap-cst-media-message-conc cst))) (imap-cst-list-list-conc-matchp cstss "dquote \"MESSAGE\" dquote sp dquote \"RFC822\" dquote"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-message-conc-of-tree-fix-cst (equal (imap-cst-media-message-conc (tree-fix cst)) (imap-cst-media-message-conc cst)))
Theorem:
(defthm imap-cst-media-message-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-message-conc cst) (imap-cst-media-message-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-subtype-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-subtype"))) (let ((__function__ 'imap-cst-media-subtype-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-media-subtype-conc (b* ((cstss (imap-cst-media-subtype-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-match (implies (imap-cst-matchp cst "media-subtype") (b* ((cstss (imap-cst-media-subtype-conc cst))) (imap-cst-list-list-conc-matchp cstss "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-of-tree-fix-cst (equal (imap-cst-media-subtype-conc (tree-fix cst)) (imap-cst-media-subtype-conc cst)))
Theorem:
(defthm imap-cst-media-subtype-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-subtype-conc cst) (imap-cst-media-subtype-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-text"))) (let ((__function__ 'imap-cst-media-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-media-text-conc (b* ((cstss (imap-cst-media-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-text-conc-match (implies (imap-cst-matchp cst "media-text") (b* ((cstss (imap-cst-media-text-conc cst))) (imap-cst-list-list-conc-matchp cstss "dquote \"TEXT\" dquote sp media-subtype"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-text-conc-of-tree-fix-cst (equal (imap-cst-media-text-conc (tree-fix cst)) (imap-cst-media-text-conc cst)))
Theorem:
(defthm imap-cst-media-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-text-conc cst) (imap-cst-media-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-message-data-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "message-data"))) (let ((__function__ 'imap-cst-message-data-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-message-data-conc (b* ((cstss (imap-cst-message-data-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-message-data-conc-match (implies (imap-cst-matchp cst "message-data") (b* ((cstss (imap-cst-message-data-conc cst))) (imap-cst-list-list-conc-matchp cstss "nz-number sp ( \"EXPUNGE\" / ( \"FETCH\" sp msg-att ) )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-message-data-conc-of-tree-fix-cst (equal (imap-cst-message-data-conc (tree-fix cst)) (imap-cst-message-data-conc cst)))
Theorem:
(defthm imap-cst-message-data-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-message-data-conc cst) (imap-cst-message-data-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-msg-att-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "msg-att"))) (let ((__function__ 'imap-cst-msg-att-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-msg-att-conc (b* ((cstss (imap-cst-msg-att-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-msg-att-conc-match (implies (imap-cst-matchp cst "msg-att") (b* ((cstss (imap-cst-msg-att-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"(\" ( msg-att-dynamic / msg-att-static ) *( sp ( msg-att-dynamic / msg-att-static ) ) \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-msg-att-conc-of-tree-fix-cst (equal (imap-cst-msg-att-conc (tree-fix cst)) (imap-cst-msg-att-conc cst)))
Theorem:
(defthm imap-cst-msg-att-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-msg-att-conc cst) (imap-cst-msg-att-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-msg-att-dynamic-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "msg-att-dynamic"))) (let ((__function__ 'imap-cst-msg-att-dynamic-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-msg-att-dynamic-conc (b* ((cstss (imap-cst-msg-att-dynamic-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-msg-att-dynamic-conc-match (implies (imap-cst-matchp cst "msg-att-dynamic") (b* ((cstss (imap-cst-msg-att-dynamic-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"FLAGS\" sp \"(\" [ flag-fetch *( sp flag-fetch ) ] \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-msg-att-dynamic-conc-of-tree-fix-cst (equal (imap-cst-msg-att-dynamic-conc (tree-fix cst)) (imap-cst-msg-att-dynamic-conc cst)))
Theorem:
(defthm imap-cst-msg-att-dynamic-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-msg-att-dynamic-conc cst) (imap-cst-msg-att-dynamic-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nil-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "nil"))) (let ((__function__ 'imap-cst-nil-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-nil-conc (b* ((cstss (imap-cst-nil-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-match (implies (imap-cst-matchp cst "nil") (b* ((cstss (imap-cst-nil-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"NIL\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-of-tree-fix-cst (equal (imap-cst-nil-conc (tree-fix cst)) (imap-cst-nil-conc cst)))
Theorem:
(defthm imap-cst-nil-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nil-conc cst) (imap-cst-nil-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)))) (let ((__function__ 'imap-cst-nstring-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-nstring-conc1 (b* ((cstss (imap-cst-nstring-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)) (b* ((cstss (imap-cst-nstring-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-of-tree-fix-cst (equal (imap-cst-nstring-conc1 (tree-fix cst)) (imap-cst-nstring-conc1 cst)))
Theorem:
(defthm imap-cst-nstring-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc1 cst) (imap-cst-nstring-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)))) (let ((__function__ 'imap-cst-nstring-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-nstring-conc2 (b* ((cstss (imap-cst-nstring-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)) (b* ((cstss (imap-cst-nstring-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "nil"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-of-tree-fix-cst (equal (imap-cst-nstring-conc2 (tree-fix cst)) (imap-cst-nstring-conc2 cst)))
Theorem:
(defthm imap-cst-nstring-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc2 cst) (imap-cst-nstring-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-number-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "number"))) (let ((__function__ 'imap-cst-number-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-number-conc (b* ((cstss (imap-cst-number-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-number-conc-match (implies (imap-cst-matchp cst "number") (b* ((cstss (imap-cst-number-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-number-conc-of-tree-fix-cst (equal (imap-cst-number-conc (tree-fix cst)) (imap-cst-number-conc cst)))
Theorem:
(defthm imap-cst-number-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-number-conc cst) (imap-cst-number-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nz-number-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "nz-number"))) (let ((__function__ 'imap-cst-nz-number-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-nz-number-conc (b* ((cstss (imap-cst-nz-number-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nz-number-conc-match (implies (imap-cst-matchp cst "nz-number") (b* ((cstss (imap-cst-nz-number-conc cst))) (imap-cst-list-list-conc-matchp cstss "digit-nz *digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nz-number-conc-of-tree-fix-cst (equal (imap-cst-nz-number-conc (tree-fix cst)) (imap-cst-nz-number-conc cst)))
Theorem:
(defthm imap-cst-nz-number-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nz-number-conc cst) (imap-cst-nz-number-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-password-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "password"))) (let ((__function__ 'imap-cst-password-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-password-conc (b* ((cstss (imap-cst-password-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-match (implies (imap-cst-matchp cst "password") (b* ((cstss (imap-cst-password-conc cst))) (imap-cst-list-list-conc-matchp cstss "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-of-tree-fix-cst (equal (imap-cst-password-conc (tree-fix cst)) (imap-cst-password-conc cst)))
Theorem:
(defthm imap-cst-password-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-password-conc cst) (imap-cst-password-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-quoted-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "quoted"))) (let ((__function__ 'imap-cst-quoted-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-quoted-conc (b* ((cstss (imap-cst-quoted-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-quoted-conc-match (implies (imap-cst-matchp cst "quoted") (b* ((cstss (imap-cst-quoted-conc cst))) (imap-cst-list-list-conc-matchp cstss "dquote *quoted-char dquote"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-quoted-conc-of-tree-fix-cst (equal (imap-cst-quoted-conc (tree-fix cst)) (imap-cst-quoted-conc cst)))
Theorem:
(defthm imap-cst-quoted-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-quoted-conc cst) (imap-cst-quoted-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-rename-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "rename"))) (let ((__function__ 'imap-cst-rename-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-rename-conc (b* ((cstss (imap-cst-rename-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-rename-conc-match (implies (imap-cst-matchp cst "rename") (b* ((cstss (imap-cst-rename-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"RENAME\" sp mailbox sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-rename-conc-of-tree-fix-cst (equal (imap-cst-rename-conc (tree-fix cst)) (imap-cst-rename-conc cst)))
Theorem:
(defthm imap-cst-rename-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-rename-conc cst) (imap-cst-rename-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "response"))) (let ((__function__ 'imap-cst-response-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-conc (b* ((cstss (imap-cst-response-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-conc-match (implies (imap-cst-matchp cst "response") (b* ((cstss (imap-cst-response-conc cst))) (imap-cst-list-list-conc-matchp cstss "*( continue-req / response-data ) response-done"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-conc-of-tree-fix-cst (equal (imap-cst-response-conc (tree-fix cst)) (imap-cst-response-conc cst)))
Theorem:
(defthm imap-cst-response-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-conc cst) (imap-cst-response-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-data-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "response-data"))) (let ((__function__ 'imap-cst-response-data-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-data-conc (b* ((cstss (imap-cst-response-data-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-data-conc-match (implies (imap-cst-matchp cst "response-data") (b* ((cstss (imap-cst-response-data-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"*\" sp ( resp-cond-state / resp-cond-bye / mailbox-data / message-data / capability-data ) crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-data-conc-of-tree-fix-cst (equal (imap-cst-response-data-conc (tree-fix cst)) (imap-cst-response-data-conc cst)))
Theorem:
(defthm imap-cst-response-data-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-data-conc cst) (imap-cst-response-data-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)))) (let ((__function__ 'imap-cst-response-done-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-done-conc1 (b* ((cstss (imap-cst-response-done-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)) (b* ((cstss (imap-cst-response-done-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "response-tagged"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-of-tree-fix-cst (equal (imap-cst-response-done-conc1 (tree-fix cst)) (imap-cst-response-done-conc1 cst)))
Theorem:
(defthm imap-cst-response-done-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc1 cst) (imap-cst-response-done-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)))) (let ((__function__ 'imap-cst-response-done-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-done-conc2 (b* ((cstss (imap-cst-response-done-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)) (b* ((cstss (imap-cst-response-done-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "response-fatal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-of-tree-fix-cst (equal (imap-cst-response-done-conc2 (tree-fix cst)) (imap-cst-response-done-conc2 cst)))
Theorem:
(defthm imap-cst-response-done-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc2 cst) (imap-cst-response-done-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-fatal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "response-fatal"))) (let ((__function__ 'imap-cst-response-fatal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-fatal-conc (b* ((cstss (imap-cst-response-fatal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-fatal-conc-match (implies (imap-cst-matchp cst "response-fatal") (b* ((cstss (imap-cst-response-fatal-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"*\" sp resp-cond-bye crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-fatal-conc-of-tree-fix-cst (equal (imap-cst-response-fatal-conc (tree-fix cst)) (imap-cst-response-fatal-conc cst)))
Theorem:
(defthm imap-cst-response-fatal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-fatal-conc cst) (imap-cst-response-fatal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-tagged-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "response-tagged"))) (let ((__function__ 'imap-cst-response-tagged-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-response-tagged-conc (b* ((cstss (imap-cst-response-tagged-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-tagged-conc-match (implies (imap-cst-matchp cst "response-tagged") (b* ((cstss (imap-cst-response-tagged-conc cst))) (imap-cst-list-list-conc-matchp cstss "tag sp resp-cond-state crlf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-tagged-conc-of-tree-fix-cst (equal (imap-cst-response-tagged-conc (tree-fix cst)) (imap-cst-response-tagged-conc cst)))
Theorem:
(defthm imap-cst-response-tagged-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-tagged-conc cst) (imap-cst-response-tagged-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-cond-auth-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-cond-auth"))) (let ((__function__ 'imap-cst-resp-cond-auth-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-resp-cond-auth-conc (b* ((cstss (imap-cst-resp-cond-auth-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-auth-conc-match (implies (imap-cst-matchp cst "resp-cond-auth") (b* ((cstss (imap-cst-resp-cond-auth-conc cst))) (imap-cst-list-list-conc-matchp cstss "( \"OK\" / \"PREAUTH\" ) sp resp-text"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-auth-conc-of-tree-fix-cst (equal (imap-cst-resp-cond-auth-conc (tree-fix cst)) (imap-cst-resp-cond-auth-conc cst)))
Theorem:
(defthm imap-cst-resp-cond-auth-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-cond-auth-conc cst) (imap-cst-resp-cond-auth-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-cond-bye-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-cond-bye"))) (let ((__function__ 'imap-cst-resp-cond-bye-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-resp-cond-bye-conc (b* ((cstss (imap-cst-resp-cond-bye-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-bye-conc-match (implies (imap-cst-matchp cst "resp-cond-bye") (b* ((cstss (imap-cst-resp-cond-bye-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"BYE\" sp resp-text"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-bye-conc-of-tree-fix-cst (equal (imap-cst-resp-cond-bye-conc (tree-fix cst)) (imap-cst-resp-cond-bye-conc cst)))
Theorem:
(defthm imap-cst-resp-cond-bye-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-cond-bye-conc cst) (imap-cst-resp-cond-bye-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-cond-state-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-cond-state"))) (let ((__function__ 'imap-cst-resp-cond-state-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-resp-cond-state-conc (b* ((cstss (imap-cst-resp-cond-state-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-state-conc-match (implies (imap-cst-matchp cst "resp-cond-state") (b* ((cstss (imap-cst-resp-cond-state-conc cst))) (imap-cst-list-list-conc-matchp cstss "( \"OK\" / \"NO\" / \"BAD\" ) sp resp-text"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-cond-state-conc-of-tree-fix-cst (equal (imap-cst-resp-cond-state-conc (tree-fix cst)) (imap-cst-resp-cond-state-conc cst)))
Theorem:
(defthm imap-cst-resp-cond-state-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-cond-state-conc cst) (imap-cst-resp-cond-state-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-specials-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-specials"))) (let ((__function__ 'imap-cst-resp-specials-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-resp-specials-conc (b* ((cstss (imap-cst-resp-specials-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-match (implies (imap-cst-matchp cst "resp-specials") (b* ((cstss (imap-cst-resp-specials-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"]\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-of-tree-fix-cst (equal (imap-cst-resp-specials-conc (tree-fix cst)) (imap-cst-resp-specials-conc cst)))
Theorem:
(defthm imap-cst-resp-specials-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-specials-conc cst) (imap-cst-resp-specials-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-text"))) (let ((__function__ 'imap-cst-resp-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-resp-text-conc (b* ((cstss (imap-cst-resp-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-text-conc-match (implies (imap-cst-matchp cst "resp-text") (b* ((cstss (imap-cst-resp-text-conc cst))) (imap-cst-list-list-conc-matchp cstss "[ \"[\" resp-text-code \"]\" sp ] text"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-text-conc-of-tree-fix-cst (equal (imap-cst-resp-text-conc (tree-fix cst)) (imap-cst-resp-text-conc cst)))
Theorem:
(defthm imap-cst-resp-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-text-conc cst) (imap-cst-resp-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-search-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "search"))) (let ((__function__ 'imap-cst-search-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-search-conc (b* ((cstss (imap-cst-search-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-search-conc-match (implies (imap-cst-matchp cst "search") (b* ((cstss (imap-cst-search-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"SEARCH\" [ sp \"CHARSET\" sp astring ] 1*( sp search-key )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-search-conc-of-tree-fix-cst (equal (imap-cst-search-conc (tree-fix cst)) (imap-cst-search-conc cst)))
Theorem:
(defthm imap-cst-search-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-search-conc cst) (imap-cst-search-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-section-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "section"))) (let ((__function__ 'imap-cst-section-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-section-conc (b* ((cstss (imap-cst-section-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-section-conc-match (implies (imap-cst-matchp cst "section") (b* ((cstss (imap-cst-section-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"[\" [ section-spec ] \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-section-conc-of-tree-fix-cst (equal (imap-cst-section-conc (tree-fix cst)) (imap-cst-section-conc cst)))
Theorem:
(defthm imap-cst-section-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-section-conc cst) (imap-cst-section-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-section-part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "section-part"))) (let ((__function__ 'imap-cst-section-part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-section-part-conc (b* ((cstss (imap-cst-section-part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-section-part-conc-match (implies (imap-cst-matchp cst "section-part") (b* ((cstss (imap-cst-section-part-conc cst))) (imap-cst-list-list-conc-matchp cstss "nz-number *( \".\" nz-number )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-section-part-conc-of-tree-fix-cst (equal (imap-cst-section-part-conc (tree-fix cst)) (imap-cst-section-part-conc cst)))
Theorem:
(defthm imap-cst-section-part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-section-part-conc cst) (imap-cst-section-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-select-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "select"))) (let ((__function__ 'imap-cst-select-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-select-conc (b* ((cstss (imap-cst-select-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-select-conc-match (implies (imap-cst-matchp cst "select") (b* ((cstss (imap-cst-select-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"SELECT\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-select-conc-of-tree-fix-cst (equal (imap-cst-select-conc (tree-fix cst)) (imap-cst-select-conc cst)))
Theorem:
(defthm imap-cst-select-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-select-conc cst) (imap-cst-select-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-seq-range-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "seq-range"))) (let ((__function__ 'imap-cst-seq-range-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-seq-range-conc (b* ((cstss (imap-cst-seq-range-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-seq-range-conc-match (implies (imap-cst-matchp cst "seq-range") (b* ((cstss (imap-cst-seq-range-conc cst))) (imap-cst-list-list-conc-matchp cstss "seq-number \":\" seq-number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-seq-range-conc-of-tree-fix-cst (equal (imap-cst-seq-range-conc (tree-fix cst)) (imap-cst-seq-range-conc cst)))
Theorem:
(defthm imap-cst-seq-range-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-seq-range-conc cst) (imap-cst-seq-range-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-sequence-set-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "sequence-set"))) (let ((__function__ 'imap-cst-sequence-set-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-sequence-set-conc (b* ((cstss (imap-cst-sequence-set-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sequence-set-conc-match (implies (imap-cst-matchp cst "sequence-set") (b* ((cstss (imap-cst-sequence-set-conc cst))) (imap-cst-list-list-conc-matchp cstss "( seq-number / seq-range ) *( \",\" sequence-set )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sequence-set-conc-of-tree-fix-cst (equal (imap-cst-sequence-set-conc (tree-fix cst)) (imap-cst-sequence-set-conc cst)))
Theorem:
(defthm imap-cst-sequence-set-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-sequence-set-conc cst) (imap-cst-sequence-set-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-status-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "status"))) (let ((__function__ 'imap-cst-status-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-status-conc (b* ((cstss (imap-cst-status-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-status-conc-match (implies (imap-cst-matchp cst "status") (b* ((cstss (imap-cst-status-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"STATUS\" sp mailbox sp \"(\" status-att *( sp status-att ) \")\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-status-conc-of-tree-fix-cst (equal (imap-cst-status-conc (tree-fix cst)) (imap-cst-status-conc cst)))
Theorem:
(defthm imap-cst-status-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-status-conc cst) (imap-cst-status-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-status-att-list-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "status-att-list"))) (let ((__function__ 'imap-cst-status-att-list-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-status-att-list-conc (b* ((cstss (imap-cst-status-att-list-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-status-att-list-conc-match (implies (imap-cst-matchp cst "status-att-list") (b* ((cstss (imap-cst-status-att-list-conc cst))) (imap-cst-list-list-conc-matchp cstss "status-att sp number *( sp status-att sp number )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-status-att-list-conc-of-tree-fix-cst (equal (imap-cst-status-att-list-conc (tree-fix cst)) (imap-cst-status-att-list-conc cst)))
Theorem:
(defthm imap-cst-status-att-list-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-status-att-list-conc cst) (imap-cst-status-att-list-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-store-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "store"))) (let ((__function__ 'imap-cst-store-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-store-conc (b* ((cstss (imap-cst-store-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-store-conc-match (implies (imap-cst-matchp cst "store") (b* ((cstss (imap-cst-store-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"STORE\" sp sequence-set sp store-att-flags"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-store-conc-of-tree-fix-cst (equal (imap-cst-store-conc (tree-fix cst)) (imap-cst-store-conc cst)))
Theorem:
(defthm imap-cst-store-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-store-conc cst) (imap-cst-store-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-store-att-flags-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "store-att-flags"))) (let ((__function__ 'imap-cst-store-att-flags-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-store-att-flags-conc (b* ((cstss (imap-cst-store-att-flags-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-store-att-flags-conc-match (implies (imap-cst-matchp cst "store-att-flags") (b* ((cstss (imap-cst-store-att-flags-conc cst))) (imap-cst-list-list-conc-matchp cstss "( [ \"+\" / \"-\" ] \"FLAGS\" [ \".SILENT\" ] ) sp ( flag-list / ( flag *( sp flag ) ) )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-store-att-flags-conc-of-tree-fix-cst (equal (imap-cst-store-att-flags-conc (tree-fix cst)) (imap-cst-store-att-flags-conc cst)))
Theorem:
(defthm imap-cst-store-att-flags-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-store-att-flags-conc cst) (imap-cst-store-att-flags-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)))) (let ((__function__ 'imap-cst-string-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-string-conc1 (b* ((cstss (imap-cst-string-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)) (b* ((cstss (imap-cst-string-conc1 cst))) (imap-cst-list-list-conc-matchp cstss "quoted"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-of-tree-fix-cst (equal (imap-cst-string-conc1 (tree-fix cst)) (imap-cst-string-conc1 cst)))
Theorem:
(defthm imap-cst-string-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc1 cst) (imap-cst-string-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)))) (let ((__function__ 'imap-cst-string-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-string-conc2 (b* ((cstss (imap-cst-string-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)) (b* ((cstss (imap-cst-string-conc2 cst))) (imap-cst-list-list-conc-matchp cstss "literal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-of-tree-fix-cst (equal (imap-cst-string-conc2 (tree-fix cst)) (imap-cst-string-conc2 cst)))
Theorem:
(defthm imap-cst-string-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc2 cst) (imap-cst-string-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-subscribe-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "subscribe"))) (let ((__function__ 'imap-cst-subscribe-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-subscribe-conc (b* ((cstss (imap-cst-subscribe-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-subscribe-conc-match (implies (imap-cst-matchp cst "subscribe") (b* ((cstss (imap-cst-subscribe-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"SUBSCRIBE\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-subscribe-conc-of-tree-fix-cst (equal (imap-cst-subscribe-conc (tree-fix cst)) (imap-cst-subscribe-conc cst)))
Theorem:
(defthm imap-cst-subscribe-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-subscribe-conc cst) (imap-cst-subscribe-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-tag-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "tag"))) (let ((__function__ 'imap-cst-tag-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-tag-conc (b* ((cstss (imap-cst-tag-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-tag-conc-match (implies (imap-cst-matchp cst "tag") (b* ((cstss (imap-cst-tag-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*<any ASTRING-CHAR except \"+\">"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-tag-conc-of-tree-fix-cst (equal (imap-cst-tag-conc (tree-fix cst)) (imap-cst-tag-conc cst)))
Theorem:
(defthm imap-cst-tag-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-tag-conc cst) (imap-cst-tag-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "text"))) (let ((__function__ 'imap-cst-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-text-conc (b* ((cstss (imap-cst-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-conc-match (implies (imap-cst-matchp cst "text") (b* ((cstss (imap-cst-text-conc cst))) (imap-cst-list-list-conc-matchp cstss "1*text-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-conc-of-tree-fix-cst (equal (imap-cst-text-conc (tree-fix cst)) (imap-cst-text-conc cst)))
Theorem:
(defthm imap-cst-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-text-conc cst) (imap-cst-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-text-char-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "text-char"))) (let ((__function__ 'imap-cst-text-char-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-text-char-conc (b* ((cstss (imap-cst-text-char-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-match (implies (imap-cst-matchp cst "text-char") (b* ((cstss (imap-cst-text-char-conc cst))) (imap-cst-list-list-conc-matchp cstss "<any CHAR except CR and LF>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-of-tree-fix-cst (equal (imap-cst-text-char-conc (tree-fix cst)) (imap-cst-text-char-conc cst)))
Theorem:
(defthm imap-cst-text-char-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-text-char-conc cst) (imap-cst-text-char-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-time-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "time"))) (let ((__function__ 'imap-cst-time-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-time-conc (b* ((cstss (imap-cst-time-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-time-conc-match (implies (imap-cst-matchp cst "time") (b* ((cstss (imap-cst-time-conc cst))) (imap-cst-list-list-conc-matchp cstss "2digit \":\" 2digit \":\" 2digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-time-conc-of-tree-fix-cst (equal (imap-cst-time-conc (tree-fix cst)) (imap-cst-time-conc cst)))
Theorem:
(defthm imap-cst-time-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-time-conc cst) (imap-cst-time-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-uid-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "uid"))) (let ((__function__ 'imap-cst-uid-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-uid-conc (b* ((cstss (imap-cst-uid-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uid-conc-match (implies (imap-cst-matchp cst "uid") (b* ((cstss (imap-cst-uid-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"UID\" sp ( copy / fetch / search / store )"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uid-conc-of-tree-fix-cst (equal (imap-cst-uid-conc (tree-fix cst)) (imap-cst-uid-conc cst)))
Theorem:
(defthm imap-cst-uid-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-uid-conc cst) (imap-cst-uid-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-uniqueid-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "uniqueid"))) (let ((__function__ 'imap-cst-uniqueid-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-uniqueid-conc (b* ((cstss (imap-cst-uniqueid-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-match (implies (imap-cst-matchp cst "uniqueid") (b* ((cstss (imap-cst-uniqueid-conc cst))) (imap-cst-list-list-conc-matchp cstss "nz-number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-of-tree-fix-cst (equal (imap-cst-uniqueid-conc (tree-fix cst)) (imap-cst-uniqueid-conc cst)))
Theorem:
(defthm imap-cst-uniqueid-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-uniqueid-conc cst) (imap-cst-uniqueid-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-unsubscribe-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "unsubscribe"))) (let ((__function__ 'imap-cst-unsubscribe-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-unsubscribe-conc (b* ((cstss (imap-cst-unsubscribe-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-unsubscribe-conc-match (implies (imap-cst-matchp cst "unsubscribe") (b* ((cstss (imap-cst-unsubscribe-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"UNSUBSCRIBE\" sp mailbox"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-unsubscribe-conc-of-tree-fix-cst (equal (imap-cst-unsubscribe-conc (tree-fix cst)) (imap-cst-unsubscribe-conc cst)))
Theorem:
(defthm imap-cst-unsubscribe-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-unsubscribe-conc cst) (imap-cst-unsubscribe-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-userid-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "userid"))) (let ((__function__ 'imap-cst-userid-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-userid-conc (b* ((cstss (imap-cst-userid-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-match (implies (imap-cst-matchp cst "userid") (b* ((cstss (imap-cst-userid-conc cst))) (imap-cst-list-list-conc-matchp cstss "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-of-tree-fix-cst (equal (imap-cst-userid-conc (tree-fix cst)) (imap-cst-userid-conc cst)))
Theorem:
(defthm imap-cst-userid-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-userid-conc cst) (imap-cst-userid-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-x-command-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "x-command"))) (let ((__function__ 'imap-cst-x-command-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-x-command-conc (b* ((cstss (imap-cst-x-command-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-x-command-conc-match (implies (imap-cst-matchp cst "x-command") (b* ((cstss (imap-cst-x-command-conc cst))) (imap-cst-list-list-conc-matchp cstss "\"X\" atom <experimental command arguments>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-x-command-conc-of-tree-fix-cst (equal (imap-cst-x-command-conc (tree-fix cst)) (imap-cst-x-command-conc cst)))
Theorem:
(defthm imap-cst-x-command-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-x-command-conc cst) (imap-cst-x-command-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-zone-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "zone"))) (let ((__function__ 'imap-cst-zone-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-zone-conc (b* ((cstss (imap-cst-zone-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-zone-conc-match (implies (imap-cst-matchp cst "zone") (b* ((cstss (imap-cst-zone-conc cst))) (imap-cst-list-list-conc-matchp cstss "( \"+\" / \"-\" ) 4digit"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-zone-conc-of-tree-fix-cst (equal (imap-cst-zone-conc (tree-fix cst)) (imap-cst-zone-conc cst)))
Theorem:
(defthm imap-cst-zone-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-zone-conc cst) (imap-cst-zone-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-crlf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "crlf"))) (let ((__function__ 'imap-cst-crlf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-crlf-conc (b* ((cstss (imap-cst-crlf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-crlf-conc-match (implies (imap-cst-matchp cst "crlf") (b* ((cstss (imap-cst-crlf-conc cst))) (imap-cst-list-list-conc-matchp cstss "cr lf"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-crlf-conc-of-tree-fix-cst (equal (imap-cst-crlf-conc (tree-fix cst)) (imap-cst-crlf-conc cst)))
Theorem:
(defthm imap-cst-crlf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-crlf-conc cst) (imap-cst-crlf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-cr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "cr"))) (let ((__function__ 'imap-cst-cr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-cr-conc (b* ((cstss (imap-cst-cr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-match (implies (imap-cst-matchp cst "cr") (b* ((cstss (imap-cst-cr-conc cst))) (imap-cst-list-list-conc-matchp cstss "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-of-tree-fix-cst (equal (imap-cst-cr-conc (tree-fix cst)) (imap-cst-cr-conc cst)))
Theorem:
(defthm imap-cst-cr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-cr-conc cst) (imap-cst-cr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit"))) (let ((__function__ 'imap-cst-digit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-digit-conc (b* ((cstss (imap-cst-digit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-match (implies (imap-cst-matchp cst "digit") (b* ((cstss (imap-cst-digit-conc cst))) (imap-cst-list-list-conc-matchp cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-of-tree-fix-cst (equal (imap-cst-digit-conc (tree-fix cst)) (imap-cst-digit-conc cst)))
Theorem:
(defthm imap-cst-digit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-conc cst) (imap-cst-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-dquote-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "dquote"))) (let ((__function__ 'imap-cst-dquote-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-dquote-conc (b* ((cstss (imap-cst-dquote-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-match (implies (imap-cst-matchp cst "dquote") (b* ((cstss (imap-cst-dquote-conc cst))) (imap-cst-list-list-conc-matchp cstss "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-of-tree-fix-cst (equal (imap-cst-dquote-conc (tree-fix cst)) (imap-cst-dquote-conc cst)))
Theorem:
(defthm imap-cst-dquote-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-dquote-conc cst) (imap-cst-dquote-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-lf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "lf"))) (let ((__function__ 'imap-cst-lf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-lf-conc (b* ((cstss (imap-cst-lf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-match (implies (imap-cst-matchp cst "lf") (b* ((cstss (imap-cst-lf-conc cst))) (imap-cst-list-list-conc-matchp cstss "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-of-tree-fix-cst (equal (imap-cst-lf-conc (tree-fix cst)) (imap-cst-lf-conc cst)))
Theorem:
(defthm imap-cst-lf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-lf-conc cst) (imap-cst-lf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-sp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "sp"))) (let ((__function__ 'imap-cst-sp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-imap-cst-sp-conc (b* ((cstss (imap-cst-sp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-match (implies (imap-cst-matchp cst "sp") (b* ((cstss (imap-cst-sp-conc cst))) (imap-cst-list-list-conc-matchp cstss "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-of-tree-fix-cst (equal (imap-cst-sp-conc (tree-fix cst)) (imap-cst-sp-conc cst)))
Theorem:
(defthm imap-cst-sp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-sp-conc cst) (imap-cst-sp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-adl-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-adl"))) (let ((__function__ 'imap-cst-addr-adl-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-addr-adl-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-addr-adl-conc-rep (b* ((csts (imap-cst-addr-adl-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-rep-match (implies (imap-cst-matchp cst "addr-adl") (b* ((csts (imap-cst-addr-adl-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-rep-of-tree-fix-cst (equal (imap-cst-addr-adl-conc-rep (tree-fix cst)) (imap-cst-addr-adl-conc-rep cst)))
Theorem:
(defthm imap-cst-addr-adl-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-adl-conc-rep cst) (imap-cst-addr-adl-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-host-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-host"))) (let ((__function__ 'imap-cst-addr-host-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-addr-host-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-addr-host-conc-rep (b* ((csts (imap-cst-addr-host-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-rep-match (implies (imap-cst-matchp cst "addr-host") (b* ((csts (imap-cst-addr-host-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-rep-of-tree-fix-cst (equal (imap-cst-addr-host-conc-rep (tree-fix cst)) (imap-cst-addr-host-conc-rep cst)))
Theorem:
(defthm imap-cst-addr-host-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-host-conc-rep cst) (imap-cst-addr-host-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-mailbox-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-mailbox"))) (let ((__function__ 'imap-cst-addr-mailbox-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-addr-mailbox-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-addr-mailbox-conc-rep (b* ((csts (imap-cst-addr-mailbox-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-match (implies (imap-cst-matchp cst "addr-mailbox") (b* ((csts (imap-cst-addr-mailbox-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-of-tree-fix-cst (equal (imap-cst-addr-mailbox-conc-rep (tree-fix cst)) (imap-cst-addr-mailbox-conc-rep cst)))
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-mailbox-conc-rep cst) (imap-cst-addr-mailbox-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-name"))) (let ((__function__ 'imap-cst-addr-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-addr-name-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-addr-name-conc-rep (b* ((csts (imap-cst-addr-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-rep-match (implies (imap-cst-matchp cst "addr-name") (b* ((csts (imap-cst-addr-name-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-rep-of-tree-fix-cst (equal (imap-cst-addr-name-conc-rep (tree-fix cst)) (imap-cst-addr-name-conc-rep cst)))
Theorem:
(defthm imap-cst-addr-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-name-conc-rep cst) (imap-cst-addr-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-astring-char-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-astring-char-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-astring-char-conc1-rep (b* ((csts (imap-cst-astring-char-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-rep-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)) (b* ((csts (imap-cst-astring-char-conc1-rep cst))) (imap-cst-list-rep-matchp csts "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-rep-of-tree-fix-cst (equal (imap-cst-astring-char-conc1-rep (tree-fix cst)) (imap-cst-astring-char-conc1-rep cst)))
Theorem:
(defthm imap-cst-astring-char-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc1-rep cst) (imap-cst-astring-char-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-astring-char-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-astring-char-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-astring-char-conc2-rep (b* ((csts (imap-cst-astring-char-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-rep-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)) (b* ((csts (imap-cst-astring-char-conc2-rep cst))) (imap-cst-list-rep-matchp csts "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-rep-of-tree-fix-cst (equal (imap-cst-astring-char-conc2-rep (tree-fix cst)) (imap-cst-astring-char-conc2-rep cst)))
Theorem:
(defthm imap-cst-astring-char-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc2-rep cst) (imap-cst-astring-char-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-atom-char-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "atom-char"))) (let ((__function__ 'imap-cst-atom-char-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-atom-char-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-atom-char-conc-rep (b* ((csts (imap-cst-atom-char-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-rep-match (implies (imap-cst-matchp cst "atom-char") (b* ((csts (imap-cst-atom-char-conc-rep cst))) (imap-cst-list-rep-matchp csts "<any CHAR except atom-specials>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-rep-of-tree-fix-cst (equal (imap-cst-atom-char-conc-rep (tree-fix cst)) (imap-cst-atom-char-conc-rep cst)))
Theorem:
(defthm imap-cst-atom-char-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-atom-char-conc-rep cst) (imap-cst-atom-char-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-auth-type-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "auth-type"))) (let ((__function__ 'imap-cst-auth-type-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-auth-type-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-auth-type-conc-rep (b* ((csts (imap-cst-auth-type-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-rep-match (implies (imap-cst-matchp cst "auth-type") (b* ((csts (imap-cst-auth-type-conc-rep cst))) (imap-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-rep-of-tree-fix-cst (equal (imap-cst-auth-type-conc-rep (tree-fix cst)) (imap-cst-auth-type-conc-rep cst)))
Theorem:
(defthm imap-cst-auth-type-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-auth-type-conc-rep cst) (imap-cst-auth-type-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-desc-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-desc"))) (let ((__function__ 'imap-cst-body-fld-desc-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-desc-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-desc-conc-rep (b* ((csts (imap-cst-body-fld-desc-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-match (implies (imap-cst-matchp cst "body-fld-desc") (b* ((csts (imap-cst-body-fld-desc-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-desc-conc-rep (tree-fix cst)) (imap-cst-body-fld-desc-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-desc-conc-rep cst) (imap-cst-body-fld-desc-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-id-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-id"))) (let ((__function__ 'imap-cst-body-fld-id-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-id-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-id-conc-rep (b* ((csts (imap-cst-body-fld-id-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-match (implies (imap-cst-matchp cst "body-fld-id") (b* ((csts (imap-cst-body-fld-id-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-id-conc-rep (tree-fix cst)) (imap-cst-body-fld-id-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-id-conc-rep cst) (imap-cst-body-fld-id-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-loc-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-loc"))) (let ((__function__ 'imap-cst-body-fld-loc-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-loc-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-loc-conc-rep (b* ((csts (imap-cst-body-fld-loc-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-match (implies (imap-cst-matchp cst "body-fld-loc") (b* ((csts (imap-cst-body-fld-loc-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-loc-conc-rep (tree-fix cst)) (imap-cst-body-fld-loc-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-loc-conc-rep cst) (imap-cst-body-fld-loc-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-lines-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-lines"))) (let ((__function__ 'imap-cst-body-fld-lines-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-lines-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-lines-conc-rep (b* ((csts (imap-cst-body-fld-lines-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-match (implies (imap-cst-matchp cst "body-fld-lines") (b* ((csts (imap-cst-body-fld-lines-conc-rep cst))) (imap-cst-list-rep-matchp csts "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-lines-conc-rep (tree-fix cst)) (imap-cst-body-fld-lines-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-lines-conc-rep cst) (imap-cst-body-fld-lines-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-md5-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-md5"))) (let ((__function__ 'imap-cst-body-fld-md5-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-md5-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-md5-conc-rep (b* ((csts (imap-cst-body-fld-md5-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-match (implies (imap-cst-matchp cst "body-fld-md5") (b* ((csts (imap-cst-body-fld-md5-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-md5-conc-rep (tree-fix cst)) (imap-cst-body-fld-md5-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-md5-conc-rep cst) (imap-cst-body-fld-md5-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-octets-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-octets"))) (let ((__function__ 'imap-cst-body-fld-octets-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-body-fld-octets-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-body-fld-octets-conc-rep (b* ((csts (imap-cst-body-fld-octets-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-match (implies (imap-cst-matchp cst "body-fld-octets") (b* ((csts (imap-cst-body-fld-octets-conc-rep cst))) (imap-cst-list-rep-matchp csts "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-of-tree-fix-cst (equal (imap-cst-body-fld-octets-conc-rep (tree-fix cst)) (imap-cst-body-fld-octets-conc-rep cst)))
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-octets-conc-rep cst) (imap-cst-body-fld-octets-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-char8-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "char8"))) (let ((__function__ 'imap-cst-char8-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-char8-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-char8-conc-rep (b* ((csts (imap-cst-char8-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-rep-match (implies (imap-cst-matchp cst "char8") (b* ((csts (imap-cst-char8-conc-rep cst))) (imap-cst-list-rep-matchp csts "%x1-FF"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-rep-of-tree-fix-cst (equal (imap-cst-char8-conc-rep (tree-fix cst)) (imap-cst-char8-conc-rep cst)))
Theorem:
(defthm imap-cst-char8-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-char8-conc-rep cst) (imap-cst-char8-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)))) (let ((__function__ 'imap-cst-command-auth-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc1-rep (b* ((csts (imap-cst-command-auth-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)) (b* ((csts (imap-cst-command-auth-conc1-rep cst))) (imap-cst-list-rep-matchp csts "append"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc1-rep (tree-fix cst)) (imap-cst-command-auth-conc1-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc1-rep cst) (imap-cst-command-auth-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)))) (let ((__function__ 'imap-cst-command-auth-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc2-rep (b* ((csts (imap-cst-command-auth-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)) (b* ((csts (imap-cst-command-auth-conc2-rep cst))) (imap-cst-list-rep-matchp csts "create"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc2-rep (tree-fix cst)) (imap-cst-command-auth-conc2-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc2-rep cst) (imap-cst-command-auth-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)))) (let ((__function__ 'imap-cst-command-auth-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc3-rep (b* ((csts (imap-cst-command-auth-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)) (b* ((csts (imap-cst-command-auth-conc3-rep cst))) (imap-cst-list-rep-matchp csts "delete"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc3-rep (tree-fix cst)) (imap-cst-command-auth-conc3-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc3-rep cst) (imap-cst-command-auth-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)))) (let ((__function__ 'imap-cst-command-auth-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc4 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc4-rep (b* ((csts (imap-cst-command-auth-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)) (b* ((csts (imap-cst-command-auth-conc4-rep cst))) (imap-cst-list-rep-matchp csts "examine"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc4-rep (tree-fix cst)) (imap-cst-command-auth-conc4-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc4-rep cst) (imap-cst-command-auth-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc5-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)))) (let ((__function__ 'imap-cst-command-auth-conc5-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc5 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc5-rep (b* ((csts (imap-cst-command-auth-conc5-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)) (b* ((csts (imap-cst-command-auth-conc5-rep cst))) (imap-cst-list-rep-matchp csts "list"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc5-rep (tree-fix cst)) (imap-cst-command-auth-conc5-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc5-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc5-rep cst) (imap-cst-command-auth-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc6-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)))) (let ((__function__ 'imap-cst-command-auth-conc6-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc6 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc6-rep (b* ((csts (imap-cst-command-auth-conc6-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)) (b* ((csts (imap-cst-command-auth-conc6-rep cst))) (imap-cst-list-rep-matchp csts "lsub"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc6-rep (tree-fix cst)) (imap-cst-command-auth-conc6-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc6-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc6-rep cst) (imap-cst-command-auth-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc7-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)))) (let ((__function__ 'imap-cst-command-auth-conc7-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc7 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc7-rep (b* ((csts (imap-cst-command-auth-conc7-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)) (b* ((csts (imap-cst-command-auth-conc7-rep cst))) (imap-cst-list-rep-matchp csts "rename"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc7-rep (tree-fix cst)) (imap-cst-command-auth-conc7-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc7-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc7-rep cst) (imap-cst-command-auth-conc7-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc8-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)))) (let ((__function__ 'imap-cst-command-auth-conc8-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc8 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc8-rep (b* ((csts (imap-cst-command-auth-conc8-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)) (b* ((csts (imap-cst-command-auth-conc8-rep cst))) (imap-cst-list-rep-matchp csts "select"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc8-rep (tree-fix cst)) (imap-cst-command-auth-conc8-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc8-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc8-rep cst) (imap-cst-command-auth-conc8-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc9-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)))) (let ((__function__ 'imap-cst-command-auth-conc9-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc9 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc9-rep (b* ((csts (imap-cst-command-auth-conc9-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)) (b* ((csts (imap-cst-command-auth-conc9-rep cst))) (imap-cst-list-rep-matchp csts "status"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc9-rep (tree-fix cst)) (imap-cst-command-auth-conc9-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc9-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc9-rep cst) (imap-cst-command-auth-conc9-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc10-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)))) (let ((__function__ 'imap-cst-command-auth-conc10-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc10 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc10-rep (b* ((csts (imap-cst-command-auth-conc10-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)) (b* ((csts (imap-cst-command-auth-conc10-rep cst))) (imap-cst-list-rep-matchp csts "subscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc10-rep (tree-fix cst)) (imap-cst-command-auth-conc10-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc10-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc10-rep cst) (imap-cst-command-auth-conc10-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc11-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)))) (let ((__function__ 'imap-cst-command-auth-conc11-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-command-auth-conc11 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-command-auth-conc11-rep (b* ((csts (imap-cst-command-auth-conc11-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-rep-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)) (b* ((csts (imap-cst-command-auth-conc11-rep cst))) (imap-cst-list-rep-matchp csts "unsubscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-rep-of-tree-fix-cst (equal (imap-cst-command-auth-conc11-rep (tree-fix cst)) (imap-cst-command-auth-conc11-rep cst)))
Theorem:
(defthm imap-cst-command-auth-conc11-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc11-rep cst) (imap-cst-command-auth-conc11-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-nz-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit-nz"))) (let ((__function__ 'imap-cst-digit-nz-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-digit-nz-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-digit-nz-conc-rep (b* ((csts (imap-cst-digit-nz-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-rep-match (implies (imap-cst-matchp cst "digit-nz") (b* ((csts (imap-cst-digit-nz-conc-rep cst))) (imap-cst-list-rep-matchp csts "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-rep-of-tree-fix-cst (equal (imap-cst-digit-nz-conc-rep (tree-fix cst)) (imap-cst-digit-nz-conc-rep cst)))
Theorem:
(defthm imap-cst-digit-nz-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-nz-conc-rep cst) (imap-cst-digit-nz-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-date-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-date"))) (let ((__function__ 'imap-cst-env-date-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-env-date-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-env-date-conc-rep (b* ((csts (imap-cst-env-date-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-rep-match (implies (imap-cst-matchp cst "env-date") (b* ((csts (imap-cst-env-date-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-rep-of-tree-fix-cst (equal (imap-cst-env-date-conc-rep (tree-fix cst)) (imap-cst-env-date-conc-rep cst)))
Theorem:
(defthm imap-cst-env-date-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-date-conc-rep cst) (imap-cst-env-date-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-in-reply-to-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-in-reply-to"))) (let ((__function__ 'imap-cst-env-in-reply-to-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-env-in-reply-to-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-env-in-reply-to-conc-rep (b* ((csts (imap-cst-env-in-reply-to-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-match (implies (imap-cst-matchp cst "env-in-reply-to") (b* ((csts (imap-cst-env-in-reply-to-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-of-tree-fix-cst (equal (imap-cst-env-in-reply-to-conc-rep (tree-fix cst)) (imap-cst-env-in-reply-to-conc-rep cst)))
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-in-reply-to-conc-rep cst) (imap-cst-env-in-reply-to-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-message-id-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-message-id"))) (let ((__function__ 'imap-cst-env-message-id-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-env-message-id-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-env-message-id-conc-rep (b* ((csts (imap-cst-env-message-id-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-rep-match (implies (imap-cst-matchp cst "env-message-id") (b* ((csts (imap-cst-env-message-id-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-rep-of-tree-fix-cst (equal (imap-cst-env-message-id-conc-rep (tree-fix cst)) (imap-cst-env-message-id-conc-rep cst)))
Theorem:
(defthm imap-cst-env-message-id-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-message-id-conc-rep cst) (imap-cst-env-message-id-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-subject-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-subject"))) (let ((__function__ 'imap-cst-env-subject-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-env-subject-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-env-subject-conc-rep (b* ((csts (imap-cst-env-subject-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-rep-match (implies (imap-cst-matchp cst "env-subject") (b* ((csts (imap-cst-env-subject-conc-rep cst))) (imap-cst-list-rep-matchp csts "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-rep-of-tree-fix-cst (equal (imap-cst-env-subject-conc-rep (tree-fix cst)) (imap-cst-env-subject-conc-rep cst)))
Theorem:
(defthm imap-cst-env-subject-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-subject-conc-rep cst) (imap-cst-env-subject-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-flag-keyword-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "flag-keyword"))) (let ((__function__ 'imap-cst-flag-keyword-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-flag-keyword-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-flag-keyword-conc-rep (b* ((csts (imap-cst-flag-keyword-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-match (implies (imap-cst-matchp cst "flag-keyword") (b* ((csts (imap-cst-flag-keyword-conc-rep cst))) (imap-cst-list-rep-matchp csts "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-of-tree-fix-cst (equal (imap-cst-flag-keyword-conc-rep (tree-fix cst)) (imap-cst-flag-keyword-conc-rep cst)))
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-flag-keyword-conc-rep cst) (imap-cst-flag-keyword-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-header-fld-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "header-fld-name"))) (let ((__function__ 'imap-cst-header-fld-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-header-fld-name-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-header-fld-name-conc-rep (b* ((csts (imap-cst-header-fld-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-match (implies (imap-cst-matchp cst "header-fld-name") (b* ((csts (imap-cst-header-fld-name-conc-rep cst))) (imap-cst-list-rep-matchp csts "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-of-tree-fix-cst (equal (imap-cst-header-fld-name-conc-rep (tree-fix cst)) (imap-cst-header-fld-name-conc-rep cst)))
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-header-fld-name-conc-rep cst) (imap-cst-header-fld-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-list-char-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-list-char-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-list-char-conc1-rep (b* ((csts (imap-cst-list-char-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-rep-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)) (b* ((csts (imap-cst-list-char-conc1-rep cst))) (imap-cst-list-rep-matchp csts "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-rep-of-tree-fix-cst (equal (imap-cst-list-char-conc1-rep (tree-fix cst)) (imap-cst-list-char-conc1-rep cst)))
Theorem:
(defthm imap-cst-list-char-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc1-rep cst) (imap-cst-list-char-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-list-char-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-list-char-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-list-char-conc2-rep (b* ((csts (imap-cst-list-char-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-rep-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)) (b* ((csts (imap-cst-list-char-conc2-rep cst))) (imap-cst-list-rep-matchp csts "list-wildcards"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-rep-of-tree-fix-cst (equal (imap-cst-list-char-conc2-rep (tree-fix cst)) (imap-cst-list-char-conc2-rep cst)))
Theorem:
(defthm imap-cst-list-char-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc2-rep cst) (imap-cst-list-char-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)))) (let ((__function__ 'imap-cst-list-char-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-list-char-conc3 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-list-char-conc3-rep (b* ((csts (imap-cst-list-char-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-rep-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)) (b* ((csts (imap-cst-list-char-conc3-rep cst))) (imap-cst-list-rep-matchp csts "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-rep-of-tree-fix-cst (equal (imap-cst-list-char-conc3-rep (tree-fix cst)) (imap-cst-list-char-conc3-rep cst)))
Theorem:
(defthm imap-cst-list-char-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc3-rep cst) (imap-cst-list-char-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-subtype-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-subtype"))) (let ((__function__ 'imap-cst-media-subtype-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-media-subtype-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-media-subtype-conc-rep (b* ((csts (imap-cst-media-subtype-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-rep-match (implies (imap-cst-matchp cst "media-subtype") (b* ((csts (imap-cst-media-subtype-conc-rep cst))) (imap-cst-list-rep-matchp csts "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-rep-of-tree-fix-cst (equal (imap-cst-media-subtype-conc-rep (tree-fix cst)) (imap-cst-media-subtype-conc-rep cst)))
Theorem:
(defthm imap-cst-media-subtype-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-subtype-conc-rep cst) (imap-cst-media-subtype-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nil-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "nil"))) (let ((__function__ 'imap-cst-nil-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-nil-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-nil-conc-rep (b* ((csts (imap-cst-nil-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-rep-match (implies (imap-cst-matchp cst "nil") (b* ((csts (imap-cst-nil-conc-rep cst))) (imap-cst-list-rep-matchp csts "\"NIL\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-rep-of-tree-fix-cst (equal (imap-cst-nil-conc-rep (tree-fix cst)) (imap-cst-nil-conc-rep cst)))
Theorem:
(defthm imap-cst-nil-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nil-conc-rep cst) (imap-cst-nil-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)))) (let ((__function__ 'imap-cst-nstring-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-nstring-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-nstring-conc1-rep (b* ((csts (imap-cst-nstring-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-rep-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)) (b* ((csts (imap-cst-nstring-conc1-rep cst))) (imap-cst-list-rep-matchp csts "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-rep-of-tree-fix-cst (equal (imap-cst-nstring-conc1-rep (tree-fix cst)) (imap-cst-nstring-conc1-rep cst)))
Theorem:
(defthm imap-cst-nstring-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc1-rep cst) (imap-cst-nstring-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)))) (let ((__function__ 'imap-cst-nstring-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-nstring-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-nstring-conc2-rep (b* ((csts (imap-cst-nstring-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-rep-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)) (b* ((csts (imap-cst-nstring-conc2-rep cst))) (imap-cst-list-rep-matchp csts "nil"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-rep-of-tree-fix-cst (equal (imap-cst-nstring-conc2-rep (tree-fix cst)) (imap-cst-nstring-conc2-rep cst)))
Theorem:
(defthm imap-cst-nstring-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc2-rep cst) (imap-cst-nstring-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-password-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "password"))) (let ((__function__ 'imap-cst-password-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-password-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-password-conc-rep (b* ((csts (imap-cst-password-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-rep-match (implies (imap-cst-matchp cst "password") (b* ((csts (imap-cst-password-conc-rep cst))) (imap-cst-list-rep-matchp csts "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-rep-of-tree-fix-cst (equal (imap-cst-password-conc-rep (tree-fix cst)) (imap-cst-password-conc-rep cst)))
Theorem:
(defthm imap-cst-password-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-password-conc-rep cst) (imap-cst-password-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)))) (let ((__function__ 'imap-cst-response-done-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-response-done-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-response-done-conc1-rep (b* ((csts (imap-cst-response-done-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-rep-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)) (b* ((csts (imap-cst-response-done-conc1-rep cst))) (imap-cst-list-rep-matchp csts "response-tagged"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-rep-of-tree-fix-cst (equal (imap-cst-response-done-conc1-rep (tree-fix cst)) (imap-cst-response-done-conc1-rep cst)))
Theorem:
(defthm imap-cst-response-done-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc1-rep cst) (imap-cst-response-done-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)))) (let ((__function__ 'imap-cst-response-done-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-response-done-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-response-done-conc2-rep (b* ((csts (imap-cst-response-done-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-rep-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)) (b* ((csts (imap-cst-response-done-conc2-rep cst))) (imap-cst-list-rep-matchp csts "response-fatal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-rep-of-tree-fix-cst (equal (imap-cst-response-done-conc2-rep (tree-fix cst)) (imap-cst-response-done-conc2-rep cst)))
Theorem:
(defthm imap-cst-response-done-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc2-rep cst) (imap-cst-response-done-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-specials-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-specials"))) (let ((__function__ 'imap-cst-resp-specials-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-resp-specials-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-resp-specials-conc-rep (b* ((csts (imap-cst-resp-specials-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-rep-match (implies (imap-cst-matchp cst "resp-specials") (b* ((csts (imap-cst-resp-specials-conc-rep cst))) (imap-cst-list-rep-matchp csts "\"]\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-rep-of-tree-fix-cst (equal (imap-cst-resp-specials-conc-rep (tree-fix cst)) (imap-cst-resp-specials-conc-rep cst)))
Theorem:
(defthm imap-cst-resp-specials-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-specials-conc-rep cst) (imap-cst-resp-specials-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)))) (let ((__function__ 'imap-cst-string-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-string-conc1 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-string-conc1-rep (b* ((csts (imap-cst-string-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-rep-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)) (b* ((csts (imap-cst-string-conc1-rep cst))) (imap-cst-list-rep-matchp csts "quoted"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-rep-of-tree-fix-cst (equal (imap-cst-string-conc1-rep (tree-fix cst)) (imap-cst-string-conc1-rep cst)))
Theorem:
(defthm imap-cst-string-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc1-rep cst) (imap-cst-string-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)))) (let ((__function__ 'imap-cst-string-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-string-conc2 cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-string-conc2-rep (b* ((csts (imap-cst-string-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-rep-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)) (b* ((csts (imap-cst-string-conc2-rep cst))) (imap-cst-list-rep-matchp csts "literal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-rep-of-tree-fix-cst (equal (imap-cst-string-conc2-rep (tree-fix cst)) (imap-cst-string-conc2-rep cst)))
Theorem:
(defthm imap-cst-string-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc2-rep cst) (imap-cst-string-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-text-char-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "text-char"))) (let ((__function__ 'imap-cst-text-char-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-text-char-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-text-char-conc-rep (b* ((csts (imap-cst-text-char-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-rep-match (implies (imap-cst-matchp cst "text-char") (b* ((csts (imap-cst-text-char-conc-rep cst))) (imap-cst-list-rep-matchp csts "<any CHAR except CR and LF>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-rep-of-tree-fix-cst (equal (imap-cst-text-char-conc-rep (tree-fix cst)) (imap-cst-text-char-conc-rep cst)))
Theorem:
(defthm imap-cst-text-char-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-text-char-conc-rep cst) (imap-cst-text-char-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-uniqueid-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "uniqueid"))) (let ((__function__ 'imap-cst-uniqueid-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-uniqueid-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-uniqueid-conc-rep (b* ((csts (imap-cst-uniqueid-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-rep-match (implies (imap-cst-matchp cst "uniqueid") (b* ((csts (imap-cst-uniqueid-conc-rep cst))) (imap-cst-list-rep-matchp csts "nz-number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-rep-of-tree-fix-cst (equal (imap-cst-uniqueid-conc-rep (tree-fix cst)) (imap-cst-uniqueid-conc-rep cst)))
Theorem:
(defthm imap-cst-uniqueid-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-uniqueid-conc-rep cst) (imap-cst-uniqueid-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-userid-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "userid"))) (let ((__function__ 'imap-cst-userid-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-userid-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-userid-conc-rep (b* ((csts (imap-cst-userid-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-rep-match (implies (imap-cst-matchp cst "userid") (b* ((csts (imap-cst-userid-conc-rep cst))) (imap-cst-list-rep-matchp csts "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-rep-of-tree-fix-cst (equal (imap-cst-userid-conc-rep (tree-fix cst)) (imap-cst-userid-conc-rep cst)))
Theorem:
(defthm imap-cst-userid-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-userid-conc-rep cst) (imap-cst-userid-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-cr-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "cr"))) (let ((__function__ 'imap-cst-cr-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-cr-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-cr-conc-rep (b* ((csts (imap-cst-cr-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-rep-match (implies (imap-cst-matchp cst "cr") (b* ((csts (imap-cst-cr-conc-rep cst))) (imap-cst-list-rep-matchp csts "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-rep-of-tree-fix-cst (equal (imap-cst-cr-conc-rep (tree-fix cst)) (imap-cst-cr-conc-rep cst)))
Theorem:
(defthm imap-cst-cr-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-cr-conc-rep cst) (imap-cst-cr-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit"))) (let ((__function__ 'imap-cst-digit-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-digit-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-digit-conc-rep (b* ((csts (imap-cst-digit-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-rep-match (implies (imap-cst-matchp cst "digit") (b* ((csts (imap-cst-digit-conc-rep cst))) (imap-cst-list-rep-matchp csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-rep-of-tree-fix-cst (equal (imap-cst-digit-conc-rep (tree-fix cst)) (imap-cst-digit-conc-rep cst)))
Theorem:
(defthm imap-cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-conc-rep cst) (imap-cst-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-dquote-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "dquote"))) (let ((__function__ 'imap-cst-dquote-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-dquote-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-dquote-conc-rep (b* ((csts (imap-cst-dquote-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-rep-match (implies (imap-cst-matchp cst "dquote") (b* ((csts (imap-cst-dquote-conc-rep cst))) (imap-cst-list-rep-matchp csts "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-rep-of-tree-fix-cst (equal (imap-cst-dquote-conc-rep (tree-fix cst)) (imap-cst-dquote-conc-rep cst)))
Theorem:
(defthm imap-cst-dquote-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-dquote-conc-rep cst) (imap-cst-dquote-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-lf-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "lf"))) (let ((__function__ 'imap-cst-lf-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-lf-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-lf-conc-rep (b* ((csts (imap-cst-lf-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-rep-match (implies (imap-cst-matchp cst "lf") (b* ((csts (imap-cst-lf-conc-rep cst))) (imap-cst-list-rep-matchp csts "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-rep-of-tree-fix-cst (equal (imap-cst-lf-conc-rep (tree-fix cst)) (imap-cst-lf-conc-rep cst)))
Theorem:
(defthm imap-cst-lf-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-lf-conc-rep cst) (imap-cst-lf-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-sp-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "sp"))) (let ((__function__ 'imap-cst-sp-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (imap-cst-sp-conc cst)))))
Theorem:
(defthm tree-listp-of-imap-cst-sp-conc-rep (b* ((csts (imap-cst-sp-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-rep-match (implies (imap-cst-matchp cst "sp") (b* ((csts (imap-cst-sp-conc-rep cst))) (imap-cst-list-rep-matchp csts "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-rep-of-tree-fix-cst (equal (imap-cst-sp-conc-rep (tree-fix cst)) (imap-cst-sp-conc-rep cst)))
Theorem:
(defthm imap-cst-sp-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-sp-conc-rep cst) (imap-cst-sp-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-adl-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-adl"))) (let ((__function__ 'imap-cst-addr-adl-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-addr-adl-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-addr-adl-conc-rep-elem (b* ((cst1 (imap-cst-addr-adl-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-rep-elem-match (implies (imap-cst-matchp cst "addr-adl") (b* ((cst1 (imap-cst-addr-adl-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-adl-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-addr-adl-conc-rep-elem (tree-fix cst)) (imap-cst-addr-adl-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-addr-adl-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-adl-conc-rep-elem cst) (imap-cst-addr-adl-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-host-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-host"))) (let ((__function__ 'imap-cst-addr-host-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-addr-host-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-addr-host-conc-rep-elem (b* ((cst1 (imap-cst-addr-host-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-rep-elem-match (implies (imap-cst-matchp cst "addr-host") (b* ((cst1 (imap-cst-addr-host-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-host-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-addr-host-conc-rep-elem (tree-fix cst)) (imap-cst-addr-host-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-addr-host-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-host-conc-rep-elem cst) (imap-cst-addr-host-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-mailbox-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-mailbox"))) (let ((__function__ 'imap-cst-addr-mailbox-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-addr-mailbox-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-addr-mailbox-conc-rep-elem (b* ((cst1 (imap-cst-addr-mailbox-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-elem-match (implies (imap-cst-matchp cst "addr-mailbox") (b* ((cst1 (imap-cst-addr-mailbox-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-addr-mailbox-conc-rep-elem (tree-fix cst)) (imap-cst-addr-mailbox-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-addr-mailbox-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-mailbox-conc-rep-elem cst) (imap-cst-addr-mailbox-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-addr-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "addr-name"))) (let ((__function__ 'imap-cst-addr-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-addr-name-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-addr-name-conc-rep-elem (b* ((cst1 (imap-cst-addr-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-rep-elem-match (implies (imap-cst-matchp cst "addr-name") (b* ((cst1 (imap-cst-addr-name-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-addr-name-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-addr-name-conc-rep-elem (tree-fix cst)) (imap-cst-addr-name-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-addr-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-addr-name-conc-rep-elem cst) (imap-cst-addr-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-astring-char-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-astring-char-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-astring-char-conc1-rep-elem (b* ((cst1 (imap-cst-astring-char-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 1)) (b* ((cst1 (imap-cst-astring-char-conc1-rep-elem cst))) (imap-cst-matchp cst1 "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-astring-char-conc1-rep-elem (tree-fix cst)) (imap-cst-astring-char-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-astring-char-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc1-rep-elem cst) (imap-cst-astring-char-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-astring-char-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-astring-char-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-astring-char-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-astring-char-conc2-rep-elem (b* ((cst1 (imap-cst-astring-char-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "astring-char") (equal (imap-cst-astring-char-conc? cst) 2)) (b* ((cst1 (imap-cst-astring-char-conc2-rep-elem cst))) (imap-cst-matchp cst1 "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-astring-char-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-astring-char-conc2-rep-elem (tree-fix cst)) (imap-cst-astring-char-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-astring-char-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-astring-char-conc2-rep-elem cst) (imap-cst-astring-char-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-atom-char-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "atom-char"))) (let ((__function__ 'imap-cst-atom-char-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-atom-char-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-atom-char-conc-rep-elem (b* ((cst1 (imap-cst-atom-char-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-rep-elem-match (implies (imap-cst-matchp cst "atom-char") (b* ((cst1 (imap-cst-atom-char-conc-rep-elem cst))) (imap-cst-matchp cst1 "<any CHAR except atom-specials>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-atom-char-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-atom-char-conc-rep-elem (tree-fix cst)) (imap-cst-atom-char-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-atom-char-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-atom-char-conc-rep-elem cst) (imap-cst-atom-char-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-auth-type-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "auth-type"))) (let ((__function__ 'imap-cst-auth-type-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-auth-type-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-auth-type-conc-rep-elem (b* ((cst1 (imap-cst-auth-type-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-rep-elem-match (implies (imap-cst-matchp cst "auth-type") (b* ((cst1 (imap-cst-auth-type-conc-rep-elem cst))) (imap-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-auth-type-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-auth-type-conc-rep-elem (tree-fix cst)) (imap-cst-auth-type-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-auth-type-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-auth-type-conc-rep-elem cst) (imap-cst-auth-type-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-desc-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-desc"))) (let ((__function__ 'imap-cst-body-fld-desc-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-desc-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-desc-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-desc-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-desc") (b* ((cst1 (imap-cst-body-fld-desc-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-desc-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-desc-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-desc-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-desc-conc-rep-elem cst) (imap-cst-body-fld-desc-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-id-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-id"))) (let ((__function__ 'imap-cst-body-fld-id-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-id-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-id-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-id-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-id") (b* ((cst1 (imap-cst-body-fld-id-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-id-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-id-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-id-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-id-conc-rep-elem cst) (imap-cst-body-fld-id-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-loc-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-loc"))) (let ((__function__ 'imap-cst-body-fld-loc-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-loc-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-loc-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-loc-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-loc") (b* ((cst1 (imap-cst-body-fld-loc-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-loc-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-loc-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-loc-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-loc-conc-rep-elem cst) (imap-cst-body-fld-loc-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-lines-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-lines"))) (let ((__function__ 'imap-cst-body-fld-lines-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-lines-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-lines-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-lines-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-lines") (b* ((cst1 (imap-cst-body-fld-lines-conc-rep-elem cst))) (imap-cst-matchp cst1 "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-lines-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-lines-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-lines-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-lines-conc-rep-elem cst) (imap-cst-body-fld-lines-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-md5-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-md5"))) (let ((__function__ 'imap-cst-body-fld-md5-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-md5-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-md5-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-md5-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-md5") (b* ((cst1 (imap-cst-body-fld-md5-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-md5-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-md5-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-md5-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-md5-conc-rep-elem cst) (imap-cst-body-fld-md5-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-body-fld-octets-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "body-fld-octets"))) (let ((__function__ 'imap-cst-body-fld-octets-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-body-fld-octets-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-body-fld-octets-conc-rep-elem (b* ((cst1 (imap-cst-body-fld-octets-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-elem-match (implies (imap-cst-matchp cst "body-fld-octets") (b* ((cst1 (imap-cst-body-fld-octets-conc-rep-elem cst))) (imap-cst-matchp cst1 "number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-body-fld-octets-conc-rep-elem (tree-fix cst)) (imap-cst-body-fld-octets-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-body-fld-octets-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-body-fld-octets-conc-rep-elem cst) (imap-cst-body-fld-octets-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-char8-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "char8"))) (let ((__function__ 'imap-cst-char8-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-char8-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-char8-conc-rep-elem (b* ((cst1 (imap-cst-char8-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-rep-elem-match (implies (imap-cst-matchp cst "char8") (b* ((cst1 (imap-cst-char8-conc-rep-elem cst))) (imap-cst-matchp cst1 "%x1-FF"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-char8-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-char8-conc-rep-elem (tree-fix cst)) (imap-cst-char8-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-char8-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-char8-conc-rep-elem cst) (imap-cst-char8-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)))) (let ((__function__ 'imap-cst-command-auth-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc1-rep-elem (b* ((cst1 (imap-cst-command-auth-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 1)) (b* ((cst1 (imap-cst-command-auth-conc1-rep-elem cst))) (imap-cst-matchp cst1 "append"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc1-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc1-rep-elem cst) (imap-cst-command-auth-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)))) (let ((__function__ 'imap-cst-command-auth-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc2-rep-elem (b* ((cst1 (imap-cst-command-auth-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 2)) (b* ((cst1 (imap-cst-command-auth-conc2-rep-elem cst))) (imap-cst-matchp cst1 "create"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc2-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc2-rep-elem cst) (imap-cst-command-auth-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)))) (let ((__function__ 'imap-cst-command-auth-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc3-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc3-rep-elem (b* ((cst1 (imap-cst-command-auth-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 3)) (b* ((cst1 (imap-cst-command-auth-conc3-rep-elem cst))) (imap-cst-matchp cst1 "delete"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc3-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc3-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc3-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc3-rep-elem cst) (imap-cst-command-auth-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)))) (let ((__function__ 'imap-cst-command-auth-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc4-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc4-rep-elem (b* ((cst1 (imap-cst-command-auth-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 4)) (b* ((cst1 (imap-cst-command-auth-conc4-rep-elem cst))) (imap-cst-matchp cst1 "examine"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc4-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc4-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc4-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc4-rep-elem cst) (imap-cst-command-auth-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc5-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)))) (let ((__function__ 'imap-cst-command-auth-conc5-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc5-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc5-rep-elem (b* ((cst1 (imap-cst-command-auth-conc5-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 5)) (b* ((cst1 (imap-cst-command-auth-conc5-rep-elem cst))) (imap-cst-matchp cst1 "list"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc5-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc5-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc5-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc5-rep-elem cst) (imap-cst-command-auth-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc6-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)))) (let ((__function__ 'imap-cst-command-auth-conc6-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc6-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc6-rep-elem (b* ((cst1 (imap-cst-command-auth-conc6-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 6)) (b* ((cst1 (imap-cst-command-auth-conc6-rep-elem cst))) (imap-cst-matchp cst1 "lsub"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc6-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc6-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc6-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc6-rep-elem cst) (imap-cst-command-auth-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc7-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)))) (let ((__function__ 'imap-cst-command-auth-conc7-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc7-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc7-rep-elem (b* ((cst1 (imap-cst-command-auth-conc7-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 7)) (b* ((cst1 (imap-cst-command-auth-conc7-rep-elem cst))) (imap-cst-matchp cst1 "rename"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc7-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc7-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc7-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc7-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc7-rep-elem cst) (imap-cst-command-auth-conc7-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc8-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)))) (let ((__function__ 'imap-cst-command-auth-conc8-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc8-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc8-rep-elem (b* ((cst1 (imap-cst-command-auth-conc8-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 8)) (b* ((cst1 (imap-cst-command-auth-conc8-rep-elem cst))) (imap-cst-matchp cst1 "select"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc8-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc8-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc8-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc8-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc8-rep-elem cst) (imap-cst-command-auth-conc8-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc9-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)))) (let ((__function__ 'imap-cst-command-auth-conc9-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc9-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc9-rep-elem (b* ((cst1 (imap-cst-command-auth-conc9-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 9)) (b* ((cst1 (imap-cst-command-auth-conc9-rep-elem cst))) (imap-cst-matchp cst1 "status"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc9-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc9-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc9-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc9-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc9-rep-elem cst) (imap-cst-command-auth-conc9-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc10-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)))) (let ((__function__ 'imap-cst-command-auth-conc10-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc10-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc10-rep-elem (b* ((cst1 (imap-cst-command-auth-conc10-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 10)) (b* ((cst1 (imap-cst-command-auth-conc10-rep-elem cst))) (imap-cst-matchp cst1 "subscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc10-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc10-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc10-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc10-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc10-rep-elem cst) (imap-cst-command-auth-conc10-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-command-auth-conc11-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)))) (let ((__function__ 'imap-cst-command-auth-conc11-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-command-auth-conc11-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-command-auth-conc11-rep-elem (b* ((cst1 (imap-cst-command-auth-conc11-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-rep-elem-match (implies (and (imap-cst-matchp cst "command-auth") (equal (imap-cst-command-auth-conc? cst) 11)) (b* ((cst1 (imap-cst-command-auth-conc11-rep-elem cst))) (imap-cst-matchp cst1 "unsubscribe"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-command-auth-conc11-rep-elem-of-tree-fix-cst (equal (imap-cst-command-auth-conc11-rep-elem (tree-fix cst)) (imap-cst-command-auth-conc11-rep-elem cst)))
Theorem:
(defthm imap-cst-command-auth-conc11-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-command-auth-conc11-rep-elem cst) (imap-cst-command-auth-conc11-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-nz-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit-nz"))) (let ((__function__ 'imap-cst-digit-nz-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-digit-nz-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-digit-nz-conc-rep-elem (b* ((cst1 (imap-cst-digit-nz-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-rep-elem-match (implies (imap-cst-matchp cst "digit-nz") (b* ((cst1 (imap-cst-digit-nz-conc-rep-elem cst))) (imap-cst-matchp cst1 "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-nz-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-digit-nz-conc-rep-elem (tree-fix cst)) (imap-cst-digit-nz-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-digit-nz-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-nz-conc-rep-elem cst) (imap-cst-digit-nz-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-date-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-date"))) (let ((__function__ 'imap-cst-env-date-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-env-date-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-env-date-conc-rep-elem (b* ((cst1 (imap-cst-env-date-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-rep-elem-match (implies (imap-cst-matchp cst "env-date") (b* ((cst1 (imap-cst-env-date-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-date-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-env-date-conc-rep-elem (tree-fix cst)) (imap-cst-env-date-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-env-date-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-date-conc-rep-elem cst) (imap-cst-env-date-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-in-reply-to-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-in-reply-to"))) (let ((__function__ 'imap-cst-env-in-reply-to-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-env-in-reply-to-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-env-in-reply-to-conc-rep-elem (b* ((cst1 (imap-cst-env-in-reply-to-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-elem-match (implies (imap-cst-matchp cst "env-in-reply-to") (b* ((cst1 (imap-cst-env-in-reply-to-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-env-in-reply-to-conc-rep-elem (tree-fix cst)) (imap-cst-env-in-reply-to-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-env-in-reply-to-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-in-reply-to-conc-rep-elem cst) (imap-cst-env-in-reply-to-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-message-id-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-message-id"))) (let ((__function__ 'imap-cst-env-message-id-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-env-message-id-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-env-message-id-conc-rep-elem (b* ((cst1 (imap-cst-env-message-id-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-rep-elem-match (implies (imap-cst-matchp cst "env-message-id") (b* ((cst1 (imap-cst-env-message-id-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-message-id-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-env-message-id-conc-rep-elem (tree-fix cst)) (imap-cst-env-message-id-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-env-message-id-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-message-id-conc-rep-elem cst) (imap-cst-env-message-id-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-env-subject-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "env-subject"))) (let ((__function__ 'imap-cst-env-subject-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-env-subject-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-env-subject-conc-rep-elem (b* ((cst1 (imap-cst-env-subject-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-rep-elem-match (implies (imap-cst-matchp cst "env-subject") (b* ((cst1 (imap-cst-env-subject-conc-rep-elem cst))) (imap-cst-matchp cst1 "nstring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-env-subject-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-env-subject-conc-rep-elem (tree-fix cst)) (imap-cst-env-subject-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-env-subject-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-env-subject-conc-rep-elem cst) (imap-cst-env-subject-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-flag-keyword-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "flag-keyword"))) (let ((__function__ 'imap-cst-flag-keyword-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-flag-keyword-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-flag-keyword-conc-rep-elem (b* ((cst1 (imap-cst-flag-keyword-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-elem-match (implies (imap-cst-matchp cst "flag-keyword") (b* ((cst1 (imap-cst-flag-keyword-conc-rep-elem cst))) (imap-cst-matchp cst1 "atom"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-flag-keyword-conc-rep-elem (tree-fix cst)) (imap-cst-flag-keyword-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-flag-keyword-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-flag-keyword-conc-rep-elem cst) (imap-cst-flag-keyword-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-header-fld-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "header-fld-name"))) (let ((__function__ 'imap-cst-header-fld-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-header-fld-name-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-header-fld-name-conc-rep-elem (b* ((cst1 (imap-cst-header-fld-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-elem-match (implies (imap-cst-matchp cst "header-fld-name") (b* ((cst1 (imap-cst-header-fld-name-conc-rep-elem cst))) (imap-cst-matchp cst1 "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-header-fld-name-conc-rep-elem (tree-fix cst)) (imap-cst-header-fld-name-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-header-fld-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-header-fld-name-conc-rep-elem cst) (imap-cst-header-fld-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)))) (let ((__function__ 'imap-cst-list-char-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-list-char-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-list-char-conc1-rep-elem (b* ((cst1 (imap-cst-list-char-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 1)) (b* ((cst1 (imap-cst-list-char-conc1-rep-elem cst))) (imap-cst-matchp cst1 "atom-char"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-list-char-conc1-rep-elem (tree-fix cst)) (imap-cst-list-char-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-list-char-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc1-rep-elem cst) (imap-cst-list-char-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)))) (let ((__function__ 'imap-cst-list-char-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-list-char-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-list-char-conc2-rep-elem (b* ((cst1 (imap-cst-list-char-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 2)) (b* ((cst1 (imap-cst-list-char-conc2-rep-elem cst))) (imap-cst-matchp cst1 "list-wildcards"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-list-char-conc2-rep-elem (tree-fix cst)) (imap-cst-list-char-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-list-char-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc2-rep-elem cst) (imap-cst-list-char-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-list-char-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)))) (let ((__function__ 'imap-cst-list-char-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-list-char-conc3-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-list-char-conc3-rep-elem (b* ((cst1 (imap-cst-list-char-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-rep-elem-match (implies (and (imap-cst-matchp cst "list-char") (equal (imap-cst-list-char-conc? cst) 3)) (b* ((cst1 (imap-cst-list-char-conc3-rep-elem cst))) (imap-cst-matchp cst1 "resp-specials"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-list-char-conc3-rep-elem-of-tree-fix-cst (equal (imap-cst-list-char-conc3-rep-elem (tree-fix cst)) (imap-cst-list-char-conc3-rep-elem cst)))
Theorem:
(defthm imap-cst-list-char-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-list-char-conc3-rep-elem cst) (imap-cst-list-char-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-media-subtype-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "media-subtype"))) (let ((__function__ 'imap-cst-media-subtype-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-media-subtype-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-media-subtype-conc-rep-elem (b* ((cst1 (imap-cst-media-subtype-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-rep-elem-match (implies (imap-cst-matchp cst "media-subtype") (b* ((cst1 (imap-cst-media-subtype-conc-rep-elem cst))) (imap-cst-matchp cst1 "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-media-subtype-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-media-subtype-conc-rep-elem (tree-fix cst)) (imap-cst-media-subtype-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-media-subtype-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-media-subtype-conc-rep-elem cst) (imap-cst-media-subtype-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nil-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "nil"))) (let ((__function__ 'imap-cst-nil-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-nil-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-nil-conc-rep-elem (b* ((cst1 (imap-cst-nil-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-rep-elem-match (implies (imap-cst-matchp cst "nil") (b* ((cst1 (imap-cst-nil-conc-rep-elem cst))) (imap-cst-matchp cst1 "\"NIL\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nil-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-nil-conc-rep-elem (tree-fix cst)) (imap-cst-nil-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-nil-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nil-conc-rep-elem cst) (imap-cst-nil-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)))) (let ((__function__ 'imap-cst-nstring-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-nstring-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-nstring-conc1-rep-elem (b* ((cst1 (imap-cst-nstring-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 1)) (b* ((cst1 (imap-cst-nstring-conc1-rep-elem cst))) (imap-cst-matchp cst1 "string"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-nstring-conc1-rep-elem (tree-fix cst)) (imap-cst-nstring-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-nstring-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc1-rep-elem cst) (imap-cst-nstring-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-nstring-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)))) (let ((__function__ 'imap-cst-nstring-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-nstring-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-nstring-conc2-rep-elem (b* ((cst1 (imap-cst-nstring-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "nstring") (equal (imap-cst-nstring-conc? cst) 2)) (b* ((cst1 (imap-cst-nstring-conc2-rep-elem cst))) (imap-cst-matchp cst1 "nil"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-nstring-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-nstring-conc2-rep-elem (tree-fix cst)) (imap-cst-nstring-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-nstring-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-nstring-conc2-rep-elem cst) (imap-cst-nstring-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-password-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "password"))) (let ((__function__ 'imap-cst-password-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-password-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-password-conc-rep-elem (b* ((cst1 (imap-cst-password-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-rep-elem-match (implies (imap-cst-matchp cst "password") (b* ((cst1 (imap-cst-password-conc-rep-elem cst))) (imap-cst-matchp cst1 "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-password-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-password-conc-rep-elem (tree-fix cst)) (imap-cst-password-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-password-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-password-conc-rep-elem cst) (imap-cst-password-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)))) (let ((__function__ 'imap-cst-response-done-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-response-done-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-response-done-conc1-rep-elem (b* ((cst1 (imap-cst-response-done-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 1)) (b* ((cst1 (imap-cst-response-done-conc1-rep-elem cst))) (imap-cst-matchp cst1 "response-tagged"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-response-done-conc1-rep-elem (tree-fix cst)) (imap-cst-response-done-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-response-done-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc1-rep-elem cst) (imap-cst-response-done-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-response-done-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)))) (let ((__function__ 'imap-cst-response-done-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-response-done-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-response-done-conc2-rep-elem (b* ((cst1 (imap-cst-response-done-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "response-done") (equal (imap-cst-response-done-conc? cst) 2)) (b* ((cst1 (imap-cst-response-done-conc2-rep-elem cst))) (imap-cst-matchp cst1 "response-fatal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-response-done-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-response-done-conc2-rep-elem (tree-fix cst)) (imap-cst-response-done-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-response-done-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-response-done-conc2-rep-elem cst) (imap-cst-response-done-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-resp-specials-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "resp-specials"))) (let ((__function__ 'imap-cst-resp-specials-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-resp-specials-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-resp-specials-conc-rep-elem (b* ((cst1 (imap-cst-resp-specials-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-rep-elem-match (implies (imap-cst-matchp cst "resp-specials") (b* ((cst1 (imap-cst-resp-specials-conc-rep-elem cst))) (imap-cst-matchp cst1 "\"]\""))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-resp-specials-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-resp-specials-conc-rep-elem (tree-fix cst)) (imap-cst-resp-specials-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-resp-specials-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-resp-specials-conc-rep-elem cst) (imap-cst-resp-specials-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)))) (let ((__function__ 'imap-cst-string-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-string-conc1-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-string-conc1-rep-elem (b* ((cst1 (imap-cst-string-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-rep-elem-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 1)) (b* ((cst1 (imap-cst-string-conc1-rep-elem cst))) (imap-cst-matchp cst1 "quoted"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc1-rep-elem-of-tree-fix-cst (equal (imap-cst-string-conc1-rep-elem (tree-fix cst)) (imap-cst-string-conc1-rep-elem cst)))
Theorem:
(defthm imap-cst-string-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc1-rep-elem cst) (imap-cst-string-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-string-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)))) (let ((__function__ 'imap-cst-string-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-string-conc2-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-string-conc2-rep-elem (b* ((cst1 (imap-cst-string-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-rep-elem-match (implies (and (imap-cst-matchp cst "string") (equal (imap-cst-string-conc? cst) 2)) (b* ((cst1 (imap-cst-string-conc2-rep-elem cst))) (imap-cst-matchp cst1 "literal"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-string-conc2-rep-elem-of-tree-fix-cst (equal (imap-cst-string-conc2-rep-elem (tree-fix cst)) (imap-cst-string-conc2-rep-elem cst)))
Theorem:
(defthm imap-cst-string-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-string-conc2-rep-elem cst) (imap-cst-string-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-text-char-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "text-char"))) (let ((__function__ 'imap-cst-text-char-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-text-char-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-text-char-conc-rep-elem (b* ((cst1 (imap-cst-text-char-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-rep-elem-match (implies (imap-cst-matchp cst "text-char") (b* ((cst1 (imap-cst-text-char-conc-rep-elem cst))) (imap-cst-matchp cst1 "<any CHAR except CR and LF>"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-text-char-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-text-char-conc-rep-elem (tree-fix cst)) (imap-cst-text-char-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-text-char-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-text-char-conc-rep-elem cst) (imap-cst-text-char-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-uniqueid-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "uniqueid"))) (let ((__function__ 'imap-cst-uniqueid-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-uniqueid-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-uniqueid-conc-rep-elem (b* ((cst1 (imap-cst-uniqueid-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-rep-elem-match (implies (imap-cst-matchp cst "uniqueid") (b* ((cst1 (imap-cst-uniqueid-conc-rep-elem cst))) (imap-cst-matchp cst1 "nz-number"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-uniqueid-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-uniqueid-conc-rep-elem (tree-fix cst)) (imap-cst-uniqueid-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-uniqueid-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-uniqueid-conc-rep-elem cst) (imap-cst-uniqueid-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-userid-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "userid"))) (let ((__function__ 'imap-cst-userid-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-userid-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-userid-conc-rep-elem (b* ((cst1 (imap-cst-userid-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-rep-elem-match (implies (imap-cst-matchp cst "userid") (b* ((cst1 (imap-cst-userid-conc-rep-elem cst))) (imap-cst-matchp cst1 "astring"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-userid-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-userid-conc-rep-elem (tree-fix cst)) (imap-cst-userid-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-userid-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-userid-conc-rep-elem cst) (imap-cst-userid-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-cr-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "cr"))) (let ((__function__ 'imap-cst-cr-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-cr-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-cr-conc-rep-elem (b* ((cst1 (imap-cst-cr-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-rep-elem-match (implies (imap-cst-matchp cst "cr") (b* ((cst1 (imap-cst-cr-conc-rep-elem cst))) (imap-cst-matchp cst1 "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-cr-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-cr-conc-rep-elem (tree-fix cst)) (imap-cst-cr-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-cr-conc-rep-elem cst) (imap-cst-cr-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-digit-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "digit"))) (let ((__function__ 'imap-cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-digit-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-digit-conc-rep-elem (b* ((cst1 (imap-cst-digit-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-rep-elem-match (implies (imap-cst-matchp cst "digit") (b* ((cst1 (imap-cst-digit-conc-rep-elem cst))) (imap-cst-matchp cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-digit-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-digit-conc-rep-elem (tree-fix cst)) (imap-cst-digit-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-digit-conc-rep-elem cst) (imap-cst-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-dquote-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "dquote"))) (let ((__function__ 'imap-cst-dquote-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-dquote-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-dquote-conc-rep-elem (b* ((cst1 (imap-cst-dquote-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-rep-elem-match (implies (imap-cst-matchp cst "dquote") (b* ((cst1 (imap-cst-dquote-conc-rep-elem cst))) (imap-cst-matchp cst1 "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-dquote-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-dquote-conc-rep-elem (tree-fix cst)) (imap-cst-dquote-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-dquote-conc-rep-elem cst) (imap-cst-dquote-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-lf-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "lf"))) (let ((__function__ 'imap-cst-lf-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-lf-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-lf-conc-rep-elem (b* ((cst1 (imap-cst-lf-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-rep-elem-match (implies (imap-cst-matchp cst "lf") (b* ((cst1 (imap-cst-lf-conc-rep-elem cst))) (imap-cst-matchp cst1 "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-lf-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-lf-conc-rep-elem (tree-fix cst)) (imap-cst-lf-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-lf-conc-rep-elem cst) (imap-cst-lf-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun imap-cst-sp-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (imap-cst-matchp cst "sp"))) (let ((__function__ 'imap-cst-sp-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (imap-cst-sp-conc-rep cst)))))
Theorem:
(defthm treep-of-imap-cst-sp-conc-rep-elem (b* ((cst1 (imap-cst-sp-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-rep-elem-match (implies (imap-cst-matchp cst "sp") (b* ((cst1 (imap-cst-sp-conc-rep-elem cst))) (imap-cst-matchp cst1 "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm imap-cst-sp-conc-rep-elem-of-tree-fix-cst (equal (imap-cst-sp-conc-rep-elem (tree-fix cst)) (imap-cst-sp-conc-rep-elem cst)))
Theorem:
(defthm imap-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (imap-cst-sp-conc-rep-elem cst) (imap-cst-sp-conc-rep-elem cst-equiv))) :rule-classes :congruence)