Tree operations specialized to *all-http-grammar-rules*.
Function:
(defun http-cst-matchp$ (tree elem) (declare (xargs :guard (and (treep tree) (elementp elem)))) (let ((__function__ 'http-cst-matchp$)) (declare (ignorable __function__)) (and (tree-terminatedp tree) (tree-match-element-p tree elem *all-http-grammar-rules*))))
Theorem:
(defthm booleanp-of-http-cst-matchp$ (b* ((yes/no (http-cst-matchp$ tree elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-matchp$-of-tree-fix-tree (equal (http-cst-matchp$ (tree-fix tree) elem) (http-cst-matchp$ tree elem)))
Theorem:
(defthm http-cst-matchp$-tree-equiv-congruence-on-tree (implies (tree-equiv tree tree-equiv) (equal (http-cst-matchp$ tree elem) (http-cst-matchp$ tree-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm http-cst-matchp$-of-element-fix-elem (equal (http-cst-matchp$ tree (element-fix elem)) (http-cst-matchp$ tree elem)))
Theorem:
(defthm http-cst-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (http-cst-matchp$ tree elem) (http-cst-matchp$ tree elem-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-list-elem-matchp$ (trees elem) (declare (xargs :guard (and (tree-listp trees) (elementp elem)))) (let ((__function__ 'http-cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-element-p trees elem *all-http-grammar-rules*))))
Theorem:
(defthm booleanp-of-http-cst-list-elem-matchp$ (b* ((yes/no (http-cst-list-elem-matchp$ trees elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-list-elem-matchp$-of-tree-list-fix-trees (equal (http-cst-list-elem-matchp$ (tree-list-fix trees) elem) (http-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm http-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (http-cst-list-elem-matchp$ trees elem) (http-cst-list-elem-matchp$ trees-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm http-cst-list-elem-matchp$-of-element-fix-elem (equal (http-cst-list-elem-matchp$ trees (element-fix elem)) (http-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm http-cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (http-cst-list-elem-matchp$ trees elem) (http-cst-list-elem-matchp$ trees elem-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-list-rep-matchp$ (trees rep) (declare (xargs :guard (and (tree-listp trees) (repetitionp rep)))) (let ((__function__ 'http-cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-repetition-p trees rep *all-http-grammar-rules*))))
Theorem:
(defthm booleanp-of-http-cst-list-rep-matchp$ (b* ((yes/no (http-cst-list-rep-matchp$ trees rep))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-list-rep-matchp$-of-tree-list-fix-trees (equal (http-cst-list-rep-matchp$ (tree-list-fix trees) rep) (http-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm http-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (http-cst-list-rep-matchp$ trees rep) (http-cst-list-rep-matchp$ trees-equiv rep))) :rule-classes :congruence)
Theorem:
(defthm http-cst-list-rep-matchp$-of-repetition-fix-rep (equal (http-cst-list-rep-matchp$ trees (repetition-fix rep)) (http-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm http-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (repetition-equiv rep rep-equiv) (equal (http-cst-list-rep-matchp$ trees rep) (http-cst-list-rep-matchp$ trees rep-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-list-list-conc-matchp$ (treess conc) (declare (xargs :guard (and (tree-list-listp treess) (concatenationp conc)))) (let ((__function__ 'http-cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-concatenation-p treess conc *all-http-grammar-rules*))))
Theorem:
(defthm booleanp-of-http-cst-list-list-conc-matchp$ (b* ((yes/no (http-cst-list-list-conc-matchp$ treess conc))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (http-cst-list-list-conc-matchp$ (tree-list-list-fix treess) conc) (http-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm http-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (http-cst-list-list-conc-matchp$ treess conc) (http-cst-list-list-conc-matchp$ treess-equiv conc))) :rule-classes :congruence)
Theorem:
(defthm http-cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (http-cst-list-list-conc-matchp$ treess (concatenation-fix conc)) (http-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm http-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (concatenation-equiv conc conc-equiv) (equal (http-cst-list-list-conc-matchp$ treess conc) (http-cst-list-list-conc-matchp$ treess conc-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-list-list-alt-matchp$ (treess alt) (declare (xargs :guard (and (tree-list-listp treess) (alternationp alt)))) (let ((__function__ 'http-cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-alternation-p treess alt *all-http-grammar-rules*))))
Theorem:
(defthm booleanp-of-http-cst-list-list-alt-matchp$ (b* ((yes/no (http-cst-list-list-alt-matchp$ treess alt))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (http-cst-list-list-alt-matchp$ (tree-list-list-fix treess) alt) (http-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm http-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (http-cst-list-list-alt-matchp$ treess alt) (http-cst-list-list-alt-matchp$ treess-equiv alt))) :rule-classes :congruence)
Theorem:
(defthm http-cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (http-cst-list-list-alt-matchp$ treess (alternation-fix alt)) (http-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm http-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (alternation-equiv alt alt-equiv) (equal (http-cst-list-list-alt-matchp$ treess alt) (http-cst-list-list-alt-matchp$ treess alt-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x0-ff-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x0-FF"))) (let ((__function__ 'http-cst-%x0-ff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x0-ff-nat (b* ((nat (http-cst-%x0-ff-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x0-ff-nat-of-tree-fix-cst (equal (http-cst-%x0-ff-nat (tree-fix cst)) (http-cst-%x0-ff-nat cst)))
Theorem:
(defthm http-cst-%x0-ff-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x0-ff-nat cst) (http-cst-%x0-ff-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x21-27-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x21-27"))) (let ((__function__ 'http-cst-%x21-27-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x21-27-nat (b* ((nat (http-cst-%x21-27-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x21-27-nat-of-tree-fix-cst (equal (http-cst-%x21-27-nat (tree-fix cst)) (http-cst-%x21-27-nat cst)))
Theorem:
(defthm http-cst-%x21-27-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x21-27-nat cst) (http-cst-%x21-27-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x21-7e-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x21-7E"))) (let ((__function__ 'http-cst-%x21-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x21-7e-nat (b* ((nat (http-cst-%x21-7e-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x21-7e-nat-of-tree-fix-cst (equal (http-cst-%x21-7e-nat (tree-fix cst)) (http-cst-%x21-7e-nat cst)))
Theorem:
(defthm http-cst-%x21-7e-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x21-7e-nat cst) (http-cst-%x21-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x23-5b-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x23-5B"))) (let ((__function__ 'http-cst-%x23-5b-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x23-5b-nat (b* ((nat (http-cst-%x23-5b-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x23-5b-nat-of-tree-fix-cst (equal (http-cst-%x23-5b-nat (tree-fix cst)) (http-cst-%x23-5b-nat cst)))
Theorem:
(defthm http-cst-%x23-5b-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x23-5b-nat cst) (http-cst-%x23-5b-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x2a-5b-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x2A-5B"))) (let ((__function__ 'http-cst-%x2a-5b-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x2a-5b-nat (b* ((nat (http-cst-%x2a-5b-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x2a-5b-nat-of-tree-fix-cst (equal (http-cst-%x2a-5b-nat (tree-fix cst)) (http-cst-%x2a-5b-nat cst)))
Theorem:
(defthm http-cst-%x2a-5b-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x2a-5b-nat cst) (http-cst-%x2a-5b-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x30-34-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x30-34"))) (let ((__function__ 'http-cst-%x30-34-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x30-34-nat (b* ((nat (http-cst-%x30-34-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x30-34-nat-of-tree-fix-cst (equal (http-cst-%x30-34-nat (tree-fix cst)) (http-cst-%x30-34-nat cst)))
Theorem:
(defthm http-cst-%x30-34-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x30-34-nat cst) (http-cst-%x30-34-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x30-35-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x30-35"))) (let ((__function__ 'http-cst-%x30-35-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x30-35-nat (b* ((nat (http-cst-%x30-35-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x30-35-nat-of-tree-fix-cst (equal (http-cst-%x30-35-nat (tree-fix cst)) (http-cst-%x30-35-nat cst)))
Theorem:
(defthm http-cst-%x30-35-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x30-35-nat cst) (http-cst-%x30-35-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x30-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x30-39"))) (let ((__function__ 'http-cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x30-39-nat (b* ((nat (http-cst-%x30-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x30-39-nat-of-tree-fix-cst (equal (http-cst-%x30-39-nat (tree-fix cst)) (http-cst-%x30-39-nat cst)))
Theorem:
(defthm http-cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x30-39-nat cst) (http-cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x31-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x31-39"))) (let ((__function__ 'http-cst-%x31-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x31-39-nat (b* ((nat (http-cst-%x31-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x31-39-nat-of-tree-fix-cst (equal (http-cst-%x31-39-nat (tree-fix cst)) (http-cst-%x31-39-nat cst)))
Theorem:
(defthm http-cst-%x31-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x31-39-nat cst) (http-cst-%x31-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x41-5a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x41-5A"))) (let ((__function__ 'http-cst-%x41-5a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x41-5a-nat (b* ((nat (http-cst-%x41-5a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x41-5a-nat-of-tree-fix-cst (equal (http-cst-%x41-5a-nat (tree-fix cst)) (http-cst-%x41-5a-nat cst)))
Theorem:
(defthm http-cst-%x41-5a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x41-5a-nat cst) (http-cst-%x41-5a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x5d-7e-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x5D-7E"))) (let ((__function__ 'http-cst-%x5d-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x5d-7e-nat (b* ((nat (http-cst-%x5d-7e-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x5d-7e-nat-of-tree-fix-cst (equal (http-cst-%x5d-7e-nat (tree-fix cst)) (http-cst-%x5d-7e-nat cst)))
Theorem:
(defthm http-cst-%x5d-7e-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x5d-7e-nat cst) (http-cst-%x5d-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x61-7a-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x61-7A"))) (let ((__function__ 'http-cst-%x61-7a-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x61-7a-nat (b* ((nat (http-cst-%x61-7a-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x61-7a-nat-of-tree-fix-cst (equal (http-cst-%x61-7a-nat (tree-fix cst)) (http-cst-%x61-7a-nat cst)))
Theorem:
(defthm http-cst-%x61-7a-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x61-7a-nat cst) (http-cst-%x61-7a-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-%x80-ff-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "%x80-FF"))) (let ((__function__ 'http-cst-%x80-ff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-http-cst-%x80-ff-nat (b* ((nat (http-cst-%x80-ff-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-%x80-ff-nat-of-tree-fix-cst (equal (http-cst-%x80-ff-nat (tree-fix cst)) (http-cst-%x80-ff-nat cst)))
Theorem:
(defthm http-cst-%x80-ff-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-%x80-ff-nat cst) (http-cst-%x80-ff-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-%x0-ff-nat-bounds (implies (http-cst-matchp cst "%x0-FF") (and (<= 0 (http-cst-%x0-ff-nat cst)) (<= (http-cst-%x0-ff-nat cst) 255))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x21-27-nat-bounds (implies (http-cst-matchp cst "%x21-27") (and (<= 33 (http-cst-%x21-27-nat cst)) (<= (http-cst-%x21-27-nat cst) 39))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x21-7e-nat-bounds (implies (http-cst-matchp cst "%x21-7E") (and (<= 33 (http-cst-%x21-7e-nat cst)) (<= (http-cst-%x21-7e-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x23-5b-nat-bounds (implies (http-cst-matchp cst "%x23-5B") (and (<= 35 (http-cst-%x23-5b-nat cst)) (<= (http-cst-%x23-5b-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x2a-5b-nat-bounds (implies (http-cst-matchp cst "%x2A-5B") (and (<= 42 (http-cst-%x2a-5b-nat cst)) (<= (http-cst-%x2a-5b-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x30-34-nat-bounds (implies (http-cst-matchp cst "%x30-34") (and (<= 48 (http-cst-%x30-34-nat cst)) (<= (http-cst-%x30-34-nat cst) 52))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x30-35-nat-bounds (implies (http-cst-matchp cst "%x30-35") (and (<= 48 (http-cst-%x30-35-nat cst)) (<= (http-cst-%x30-35-nat cst) 53))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x30-39-nat-bounds (implies (http-cst-matchp cst "%x30-39") (and (<= 48 (http-cst-%x30-39-nat cst)) (<= (http-cst-%x30-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x31-39-nat-bounds (implies (http-cst-matchp cst "%x31-39") (and (<= 49 (http-cst-%x31-39-nat cst)) (<= (http-cst-%x31-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x41-5a-nat-bounds (implies (http-cst-matchp cst "%x41-5A") (and (<= 65 (http-cst-%x41-5a-nat cst)) (<= (http-cst-%x41-5a-nat cst) 90))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x5d-7e-nat-bounds (implies (http-cst-matchp cst "%x5D-7E") (and (<= 93 (http-cst-%x5d-7e-nat cst)) (<= (http-cst-%x5d-7e-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x61-7a-nat-bounds (implies (http-cst-matchp cst "%x61-7A") (and (<= 97 (http-cst-%x61-7a-nat cst)) (<= (http-cst-%x61-7a-nat cst) 122))) :rule-classes :linear)
Theorem:
(defthm http-cst-%x80-ff-nat-bounds (implies (http-cst-matchp cst "%x80-FF") (and (<= 128 (http-cst-%x80-ff-nat cst)) (<= (http-cst-%x80-ff-nat cst) 255))) :rule-classes :linear)
Theorem:
(defthm |HTTP-CST-"!"-LEAFTERM| (implies (http-cst-matchp cst "\"!\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"#"-LEAFTERM| (implies (http-cst-matchp cst "\"#\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"$"-LEAFTERM| (implies (http-cst-matchp cst "\"$\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"%"-LEAFTERM| (implies (http-cst-matchp cst "\"%\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"&"-LEAFTERM| (implies (http-cst-matchp cst "\"&\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"'"-LEAFTERM| (implies (http-cst-matchp cst "\"'\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"("-LEAFTERM| (implies (http-cst-matchp cst "\"(\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-")"-LEAFTERM| (implies (http-cst-matchp cst "\")\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"*"-LEAFTERM| (implies (http-cst-matchp cst "\"*\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"+"-LEAFTERM| (implies (http-cst-matchp cst "\"+\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-","-LEAFTERM| (implies (http-cst-matchp cst "\",\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"-"-LEAFTERM| (implies (http-cst-matchp cst "\"-\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"."-LEAFTERM| (implies (http-cst-matchp cst "\".\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"/"-LEAFTERM| (implies (http-cst-matchp cst "\"/\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"//"-LEAFTERM| (implies (http-cst-matchp cst "\"//\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"0"-LEAFTERM| (implies (http-cst-matchp cst "\"0\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"1"-LEAFTERM| (implies (http-cst-matchp cst "\"1\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"2"-LEAFTERM| (implies (http-cst-matchp cst "\"2\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"25"-LEAFTERM| (implies (http-cst-matchp cst "\"25\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-":"-LEAFTERM| (implies (http-cst-matchp cst "\":\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"::"-LEAFTERM| (implies (http-cst-matchp cst "\"::\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-";"-LEAFTERM| (implies (http-cst-matchp cst "\";\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"="-LEAFTERM| (implies (http-cst-matchp cst "\"=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"?"-LEAFTERM| (implies (http-cst-matchp cst "\"?\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"@"-LEAFTERM| (implies (http-cst-matchp cst "\"@\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"A"-LEAFTERM| (implies (http-cst-matchp cst "\"A\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"B"-LEAFTERM| (implies (http-cst-matchp cst "\"B\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"C"-LEAFTERM| (implies (http-cst-matchp cst "\"C\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"D"-LEAFTERM| (implies (http-cst-matchp cst "\"D\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"E"-LEAFTERM| (implies (http-cst-matchp cst "\"E\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"F"-LEAFTERM| (implies (http-cst-matchp cst "\"F\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"["-LEAFTERM| (implies (http-cst-matchp cst "\"[\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"\\"-LEAFTERM| (implies (http-cst-matchp cst "\"\\\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"]"-LEAFTERM| (implies (http-cst-matchp cst "\"]\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"^"-LEAFTERM| (implies (http-cst-matchp cst "\"^\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"_"-LEAFTERM| (implies (http-cst-matchp cst "\"_\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"`"-LEAFTERM| (implies (http-cst-matchp cst "\"`\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"chunked"-LEAFTERM| (implies (http-cst-matchp cst "\"chunked\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"compress"-LEAFTERM| (implies (http-cst-matchp cst "\"compress\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"deflate"-LEAFTERM| (implies (http-cst-matchp cst "\"deflate\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"gzip"-LEAFTERM| (implies (http-cst-matchp cst "\"gzip\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"http://"-LEAFTERM| (implies (http-cst-matchp cst "\"http://\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"https://"-LEAFTERM| (implies (http-cst-matchp cst "\"https://\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"q="-LEAFTERM| (implies (http-cst-matchp cst "\"q=\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"trailers"-LEAFTERM| (implies (http-cst-matchp cst "\"trailers\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"v"-LEAFTERM| (implies (http-cst-matchp cst "\"v\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"\|"-LEAFTERM| (implies (http-cst-matchp cst "\"|\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |HTTP-CST-"~"-LEAFTERM| (implies (http-cst-matchp cst "\"~\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm http-cst-bws-nonleaf (implies (http-cst-matchp cst "bws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-connection-nonleaf (implies (http-cst-matchp cst "connection") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-content-length-nonleaf (implies (http-cst-matchp cst "content-length") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-http-message-nonleaf (implies (http-cst-matchp cst "http-message") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-http-name-nonleaf (implies (http-cst-matchp cst "http-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-http-version-nonleaf (implies (http-cst-matchp cst "http-version") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-host-nonleaf (implies (http-cst-matchp cst "host") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ows-nonleaf (implies (http-cst-matchp cst "ows") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-rws-nonleaf (implies (http-cst-matchp cst "rws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-te-nonleaf (implies (http-cst-matchp cst "te") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-trailer-nonleaf (implies (http-cst-matchp cst "trailer") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-transfer-encoding-nonleaf (implies (http-cst-matchp cst "transfer-encoding") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-upgrade-nonleaf (implies (http-cst-matchp cst "upgrade") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-via-nonleaf (implies (http-cst-matchp cst "via") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-absolute-form-nonleaf (implies (http-cst-matchp cst "absolute-form") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-absolute-path-nonleaf (implies (http-cst-matchp cst "absolute-path") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-asterisk-form-nonleaf (implies (http-cst-matchp cst "asterisk-form") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-authority-form-nonleaf (implies (http-cst-matchp cst "authority-form") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-nonleaf (implies (http-cst-matchp cst "chunk") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-data-nonleaf (implies (http-cst-matchp cst "chunk-data") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-ext-nonleaf (implies (http-cst-matchp cst "chunk-ext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-ext-name-nonleaf (implies (http-cst-matchp cst "chunk-ext-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-ext-val-nonleaf (implies (http-cst-matchp cst "chunk-ext-val") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunk-size-nonleaf (implies (http-cst-matchp cst "chunk-size") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-chunked-body-nonleaf (implies (http-cst-matchp cst "chunked-body") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-comment-nonleaf (implies (http-cst-matchp cst "comment") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-connection-option-nonleaf (implies (http-cst-matchp cst "connection-option") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ctext-nonleaf (implies (http-cst-matchp cst "ctext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-field-content-nonleaf (implies (http-cst-matchp cst "field-content") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-field-name-nonleaf (implies (http-cst-matchp cst "field-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-field-value-nonleaf (implies (http-cst-matchp cst "field-value") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-field-vchar-nonleaf (implies (http-cst-matchp cst "field-vchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-header-field-nonleaf (implies (http-cst-matchp cst "header-field") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-http-uri-nonleaf (implies (http-cst-matchp cst "http-uri") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-https-uri-nonleaf (implies (http-cst-matchp cst "https-uri") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-last-chunk-nonleaf (implies (http-cst-matchp cst "last-chunk") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-message-body-nonleaf (implies (http-cst-matchp cst "message-body") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-method-nonleaf (implies (http-cst-matchp cst "method") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-obs-fold-nonleaf (implies (http-cst-matchp cst "obs-fold") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-obs-text-nonleaf (implies (http-cst-matchp cst "obs-text") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-origin-form-nonleaf (implies (http-cst-matchp cst "origin-form") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-partial-uri-nonleaf (implies (http-cst-matchp cst "partial-uri") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-protocol-nonleaf (implies (http-cst-matchp cst "protocol") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-protocol-name-nonleaf (implies (http-cst-matchp cst "protocol-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-protocol-version-nonleaf (implies (http-cst-matchp cst "protocol-version") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-pseudonym-nonleaf (implies (http-cst-matchp cst "pseudonym") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-qdtext-nonleaf (implies (http-cst-matchp cst "qdtext") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-quoted-pair-nonleaf (implies (http-cst-matchp cst "quoted-pair") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-quoted-string-nonleaf (implies (http-cst-matchp cst "quoted-string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-rank-nonleaf (implies (http-cst-matchp cst "rank") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-reason-phrase-nonleaf (implies (http-cst-matchp cst "reason-phrase") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-received-by-nonleaf (implies (http-cst-matchp cst "received-by") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-received-protocol-nonleaf (implies (http-cst-matchp cst "received-protocol") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-request-line-nonleaf (implies (http-cst-matchp cst "request-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-request-target-nonleaf (implies (http-cst-matchp cst "request-target") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-start-line-nonleaf (implies (http-cst-matchp cst "start-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-status-code-nonleaf (implies (http-cst-matchp cst "status-code") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-status-line-nonleaf (implies (http-cst-matchp cst "status-line") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-t-codings-nonleaf (implies (http-cst-matchp cst "t-codings") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-t-ranking-nonleaf (implies (http-cst-matchp cst "t-ranking") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-tchar-nonleaf (implies (http-cst-matchp cst "tchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-token-nonleaf (implies (http-cst-matchp cst "token") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-trailer-part-nonleaf (implies (http-cst-matchp cst "trailer-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-transfer-coding-nonleaf (implies (http-cst-matchp cst "transfer-coding") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-transfer-extension-nonleaf (implies (http-cst-matchp cst "transfer-extension") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-transfer-parameter-nonleaf (implies (http-cst-matchp cst "transfer-parameter") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-absolute-uri-nonleaf (implies (http-cst-matchp cst "absolute-uri") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-authority-nonleaf (implies (http-cst-matchp cst "authority") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-fragment-nonleaf (implies (http-cst-matchp cst "fragment") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-hier-part-nonleaf (implies (http-cst-matchp cst "hier-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-path-abempty-nonleaf (implies (http-cst-matchp cst "path-abempty") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-path-absolute-nonleaf (implies (http-cst-matchp cst "path-absolute") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-path-empty-nonleaf (implies (http-cst-matchp cst "path-empty") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-path-rootless-nonleaf (implies (http-cst-matchp cst "path-rootless") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-pchar-nonleaf (implies (http-cst-matchp cst "pchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-pct-encoded-nonleaf (implies (http-cst-matchp cst "pct-encoded") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-port-nonleaf (implies (http-cst-matchp cst "port") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-query-nonleaf (implies (http-cst-matchp cst "query") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-relative-part-nonleaf (implies (http-cst-matchp cst "relative-part") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-path-noscheme-nonleaf (implies (http-cst-matchp cst "path-noscheme") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-scheme-nonleaf (implies (http-cst-matchp cst "scheme") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-segment-nonleaf (implies (http-cst-matchp cst "segment") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-segment-nz-nonleaf (implies (http-cst-matchp cst "segment-nz") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-segment-nz-nc-nonleaf (implies (http-cst-matchp cst "segment-nz-nc") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-sub-delims-nonleaf (implies (http-cst-matchp cst "sub-delims") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-unreserved-nonleaf (implies (http-cst-matchp cst "unreserved") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-uri-host-nonleaf (implies (http-cst-matchp cst "uri-host") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ip-literal-nonleaf (implies (http-cst-matchp cst "ip-literal") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ipv4address-nonleaf (implies (http-cst-matchp cst "ipv4address") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-dec-octet-nonleaf (implies (http-cst-matchp cst "dec-octet") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ipv6address-nonleaf (implies (http-cst-matchp cst "ipv6address") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-h16-nonleaf (implies (http-cst-matchp cst "h16") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ipvfuture-nonleaf (implies (http-cst-matchp cst "ipvfuture") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-ls32-nonleaf (implies (http-cst-matchp cst "ls32") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-reg-name-nonleaf (implies (http-cst-matchp cst "reg-name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-userinfo-nonleaf (implies (http-cst-matchp cst "userinfo") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-alpha-nonleaf (implies (http-cst-matchp cst "alpha") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-crlf-nonleaf (implies (http-cst-matchp cst "crlf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-cr-nonleaf (implies (http-cst-matchp cst "cr") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-digit-nonleaf (implies (http-cst-matchp cst "digit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-dquote-nonleaf (implies (http-cst-matchp cst "dquote") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-hexdig-nonleaf (implies (http-cst-matchp cst "hexdig") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-htab-nonleaf (implies (http-cst-matchp cst "htab") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-lf-nonleaf (implies (http-cst-matchp cst "lf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-octet-nonleaf (implies (http-cst-matchp cst "octet") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-sp-nonleaf (implies (http-cst-matchp cst "sp") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-vchar-nonleaf (implies (http-cst-matchp cst "vchar") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm http-cst-bws-rulename (implies (http-cst-matchp cst "bws") (equal (tree-nonleaf->rulename? cst) (rulename "bws"))))
Theorem:
(defthm http-cst-connection-rulename (implies (http-cst-matchp cst "connection") (equal (tree-nonleaf->rulename? cst) (rulename "connection"))))
Theorem:
(defthm http-cst-content-length-rulename (implies (http-cst-matchp cst "content-length") (equal (tree-nonleaf->rulename? cst) (rulename "content-length"))))
Theorem:
(defthm http-cst-http-message-rulename (implies (http-cst-matchp cst "http-message") (equal (tree-nonleaf->rulename? cst) (rulename "http-message"))))
Theorem:
(defthm http-cst-http-name-rulename (implies (http-cst-matchp cst "http-name") (equal (tree-nonleaf->rulename? cst) (rulename "http-name"))))
Theorem:
(defthm http-cst-http-version-rulename (implies (http-cst-matchp cst "http-version") (equal (tree-nonleaf->rulename? cst) (rulename "http-version"))))
Theorem:
(defthm http-cst-host-rulename (implies (http-cst-matchp cst "host") (equal (tree-nonleaf->rulename? cst) (rulename "host"))))
Theorem:
(defthm http-cst-ows-rulename (implies (http-cst-matchp cst "ows") (equal (tree-nonleaf->rulename? cst) (rulename "ows"))))
Theorem:
(defthm http-cst-rws-rulename (implies (http-cst-matchp cst "rws") (equal (tree-nonleaf->rulename? cst) (rulename "rws"))))
Theorem:
(defthm http-cst-te-rulename (implies (http-cst-matchp cst "te") (equal (tree-nonleaf->rulename? cst) (rulename "te"))))
Theorem:
(defthm http-cst-trailer-rulename (implies (http-cst-matchp cst "trailer") (equal (tree-nonleaf->rulename? cst) (rulename "trailer"))))
Theorem:
(defthm http-cst-transfer-encoding-rulename (implies (http-cst-matchp cst "transfer-encoding") (equal (tree-nonleaf->rulename? cst) (rulename "transfer-encoding"))))
Theorem:
(defthm http-cst-upgrade-rulename (implies (http-cst-matchp cst "upgrade") (equal (tree-nonleaf->rulename? cst) (rulename "upgrade"))))
Theorem:
(defthm http-cst-via-rulename (implies (http-cst-matchp cst "via") (equal (tree-nonleaf->rulename? cst) (rulename "via"))))
Theorem:
(defthm http-cst-absolute-form-rulename (implies (http-cst-matchp cst "absolute-form") (equal (tree-nonleaf->rulename? cst) (rulename "absolute-form"))))
Theorem:
(defthm http-cst-absolute-path-rulename (implies (http-cst-matchp cst "absolute-path") (equal (tree-nonleaf->rulename? cst) (rulename "absolute-path"))))
Theorem:
(defthm http-cst-asterisk-form-rulename (implies (http-cst-matchp cst "asterisk-form") (equal (tree-nonleaf->rulename? cst) (rulename "asterisk-form"))))
Theorem:
(defthm http-cst-authority-form-rulename (implies (http-cst-matchp cst "authority-form") (equal (tree-nonleaf->rulename? cst) (rulename "authority-form"))))
Theorem:
(defthm http-cst-chunk-rulename (implies (http-cst-matchp cst "chunk") (equal (tree-nonleaf->rulename? cst) (rulename "chunk"))))
Theorem:
(defthm http-cst-chunk-data-rulename (implies (http-cst-matchp cst "chunk-data") (equal (tree-nonleaf->rulename? cst) (rulename "chunk-data"))))
Theorem:
(defthm http-cst-chunk-ext-rulename (implies (http-cst-matchp cst "chunk-ext") (equal (tree-nonleaf->rulename? cst) (rulename "chunk-ext"))))
Theorem:
(defthm http-cst-chunk-ext-name-rulename (implies (http-cst-matchp cst "chunk-ext-name") (equal (tree-nonleaf->rulename? cst) (rulename "chunk-ext-name"))))
Theorem:
(defthm http-cst-chunk-ext-val-rulename (implies (http-cst-matchp cst "chunk-ext-val") (equal (tree-nonleaf->rulename? cst) (rulename "chunk-ext-val"))))
Theorem:
(defthm http-cst-chunk-size-rulename (implies (http-cst-matchp cst "chunk-size") (equal (tree-nonleaf->rulename? cst) (rulename "chunk-size"))))
Theorem:
(defthm http-cst-chunked-body-rulename (implies (http-cst-matchp cst "chunked-body") (equal (tree-nonleaf->rulename? cst) (rulename "chunked-body"))))
Theorem:
(defthm http-cst-comment-rulename (implies (http-cst-matchp cst "comment") (equal (tree-nonleaf->rulename? cst) (rulename "comment"))))
Theorem:
(defthm http-cst-connection-option-rulename (implies (http-cst-matchp cst "connection-option") (equal (tree-nonleaf->rulename? cst) (rulename "connection-option"))))
Theorem:
(defthm http-cst-ctext-rulename (implies (http-cst-matchp cst "ctext") (equal (tree-nonleaf->rulename? cst) (rulename "ctext"))))
Theorem:
(defthm http-cst-field-content-rulename (implies (http-cst-matchp cst "field-content") (equal (tree-nonleaf->rulename? cst) (rulename "field-content"))))
Theorem:
(defthm http-cst-field-name-rulename (implies (http-cst-matchp cst "field-name") (equal (tree-nonleaf->rulename? cst) (rulename "field-name"))))
Theorem:
(defthm http-cst-field-value-rulename (implies (http-cst-matchp cst "field-value") (equal (tree-nonleaf->rulename? cst) (rulename "field-value"))))
Theorem:
(defthm http-cst-field-vchar-rulename (implies (http-cst-matchp cst "field-vchar") (equal (tree-nonleaf->rulename? cst) (rulename "field-vchar"))))
Theorem:
(defthm http-cst-header-field-rulename (implies (http-cst-matchp cst "header-field") (equal (tree-nonleaf->rulename? cst) (rulename "header-field"))))
Theorem:
(defthm http-cst-http-uri-rulename (implies (http-cst-matchp cst "http-uri") (equal (tree-nonleaf->rulename? cst) (rulename "http-uri"))))
Theorem:
(defthm http-cst-https-uri-rulename (implies (http-cst-matchp cst "https-uri") (equal (tree-nonleaf->rulename? cst) (rulename "https-uri"))))
Theorem:
(defthm http-cst-last-chunk-rulename (implies (http-cst-matchp cst "last-chunk") (equal (tree-nonleaf->rulename? cst) (rulename "last-chunk"))))
Theorem:
(defthm http-cst-message-body-rulename (implies (http-cst-matchp cst "message-body") (equal (tree-nonleaf->rulename? cst) (rulename "message-body"))))
Theorem:
(defthm http-cst-method-rulename (implies (http-cst-matchp cst "method") (equal (tree-nonleaf->rulename? cst) (rulename "method"))))
Theorem:
(defthm http-cst-obs-fold-rulename (implies (http-cst-matchp cst "obs-fold") (equal (tree-nonleaf->rulename? cst) (rulename "obs-fold"))))
Theorem:
(defthm http-cst-obs-text-rulename (implies (http-cst-matchp cst "obs-text") (equal (tree-nonleaf->rulename? cst) (rulename "obs-text"))))
Theorem:
(defthm http-cst-origin-form-rulename (implies (http-cst-matchp cst "origin-form") (equal (tree-nonleaf->rulename? cst) (rulename "origin-form"))))
Theorem:
(defthm http-cst-partial-uri-rulename (implies (http-cst-matchp cst "partial-uri") (equal (tree-nonleaf->rulename? cst) (rulename "partial-uri"))))
Theorem:
(defthm http-cst-protocol-rulename (implies (http-cst-matchp cst "protocol") (equal (tree-nonleaf->rulename? cst) (rulename "protocol"))))
Theorem:
(defthm http-cst-protocol-name-rulename (implies (http-cst-matchp cst "protocol-name") (equal (tree-nonleaf->rulename? cst) (rulename "protocol-name"))))
Theorem:
(defthm http-cst-protocol-version-rulename (implies (http-cst-matchp cst "protocol-version") (equal (tree-nonleaf->rulename? cst) (rulename "protocol-version"))))
Theorem:
(defthm http-cst-pseudonym-rulename (implies (http-cst-matchp cst "pseudonym") (equal (tree-nonleaf->rulename? cst) (rulename "pseudonym"))))
Theorem:
(defthm http-cst-qdtext-rulename (implies (http-cst-matchp cst "qdtext") (equal (tree-nonleaf->rulename? cst) (rulename "qdtext"))))
Theorem:
(defthm http-cst-quoted-pair-rulename (implies (http-cst-matchp cst "quoted-pair") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-pair"))))
Theorem:
(defthm http-cst-quoted-string-rulename (implies (http-cst-matchp cst "quoted-string") (equal (tree-nonleaf->rulename? cst) (rulename "quoted-string"))))
Theorem:
(defthm http-cst-rank-rulename (implies (http-cst-matchp cst "rank") (equal (tree-nonleaf->rulename? cst) (rulename "rank"))))
Theorem:
(defthm http-cst-reason-phrase-rulename (implies (http-cst-matchp cst "reason-phrase") (equal (tree-nonleaf->rulename? cst) (rulename "reason-phrase"))))
Theorem:
(defthm http-cst-received-by-rulename (implies (http-cst-matchp cst "received-by") (equal (tree-nonleaf->rulename? cst) (rulename "received-by"))))
Theorem:
(defthm http-cst-received-protocol-rulename (implies (http-cst-matchp cst "received-protocol") (equal (tree-nonleaf->rulename? cst) (rulename "received-protocol"))))
Theorem:
(defthm http-cst-request-line-rulename (implies (http-cst-matchp cst "request-line") (equal (tree-nonleaf->rulename? cst) (rulename "request-line"))))
Theorem:
(defthm http-cst-request-target-rulename (implies (http-cst-matchp cst "request-target") (equal (tree-nonleaf->rulename? cst) (rulename "request-target"))))
Theorem:
(defthm http-cst-start-line-rulename (implies (http-cst-matchp cst "start-line") (equal (tree-nonleaf->rulename? cst) (rulename "start-line"))))
Theorem:
(defthm http-cst-status-code-rulename (implies (http-cst-matchp cst "status-code") (equal (tree-nonleaf->rulename? cst) (rulename "status-code"))))
Theorem:
(defthm http-cst-status-line-rulename (implies (http-cst-matchp cst "status-line") (equal (tree-nonleaf->rulename? cst) (rulename "status-line"))))
Theorem:
(defthm http-cst-t-codings-rulename (implies (http-cst-matchp cst "t-codings") (equal (tree-nonleaf->rulename? cst) (rulename "t-codings"))))
Theorem:
(defthm http-cst-t-ranking-rulename (implies (http-cst-matchp cst "t-ranking") (equal (tree-nonleaf->rulename? cst) (rulename "t-ranking"))))
Theorem:
(defthm http-cst-tchar-rulename (implies (http-cst-matchp cst "tchar") (equal (tree-nonleaf->rulename? cst) (rulename "tchar"))))
Theorem:
(defthm http-cst-token-rulename (implies (http-cst-matchp cst "token") (equal (tree-nonleaf->rulename? cst) (rulename "token"))))
Theorem:
(defthm http-cst-trailer-part-rulename (implies (http-cst-matchp cst "trailer-part") (equal (tree-nonleaf->rulename? cst) (rulename "trailer-part"))))
Theorem:
(defthm http-cst-transfer-coding-rulename (implies (http-cst-matchp cst "transfer-coding") (equal (tree-nonleaf->rulename? cst) (rulename "transfer-coding"))))
Theorem:
(defthm http-cst-transfer-extension-rulename (implies (http-cst-matchp cst "transfer-extension") (equal (tree-nonleaf->rulename? cst) (rulename "transfer-extension"))))
Theorem:
(defthm http-cst-transfer-parameter-rulename (implies (http-cst-matchp cst "transfer-parameter") (equal (tree-nonleaf->rulename? cst) (rulename "transfer-parameter"))))
Theorem:
(defthm http-cst-absolute-uri-rulename (implies (http-cst-matchp cst "absolute-uri") (equal (tree-nonleaf->rulename? cst) (rulename "absolute-uri"))))
Theorem:
(defthm http-cst-authority-rulename (implies (http-cst-matchp cst "authority") (equal (tree-nonleaf->rulename? cst) (rulename "authority"))))
Theorem:
(defthm http-cst-fragment-rulename (implies (http-cst-matchp cst "fragment") (equal (tree-nonleaf->rulename? cst) (rulename "fragment"))))
Theorem:
(defthm http-cst-hier-part-rulename (implies (http-cst-matchp cst "hier-part") (equal (tree-nonleaf->rulename? cst) (rulename "hier-part"))))
Theorem:
(defthm http-cst-path-abempty-rulename (implies (http-cst-matchp cst "path-abempty") (equal (tree-nonleaf->rulename? cst) (rulename "path-abempty"))))
Theorem:
(defthm http-cst-path-absolute-rulename (implies (http-cst-matchp cst "path-absolute") (equal (tree-nonleaf->rulename? cst) (rulename "path-absolute"))))
Theorem:
(defthm http-cst-path-empty-rulename (implies (http-cst-matchp cst "path-empty") (equal (tree-nonleaf->rulename? cst) (rulename "path-empty"))))
Theorem:
(defthm http-cst-path-rootless-rulename (implies (http-cst-matchp cst "path-rootless") (equal (tree-nonleaf->rulename? cst) (rulename "path-rootless"))))
Theorem:
(defthm http-cst-pchar-rulename (implies (http-cst-matchp cst "pchar") (equal (tree-nonleaf->rulename? cst) (rulename "pchar"))))
Theorem:
(defthm http-cst-pct-encoded-rulename (implies (http-cst-matchp cst "pct-encoded") (equal (tree-nonleaf->rulename? cst) (rulename "pct-encoded"))))
Theorem:
(defthm http-cst-port-rulename (implies (http-cst-matchp cst "port") (equal (tree-nonleaf->rulename? cst) (rulename "port"))))
Theorem:
(defthm http-cst-query-rulename (implies (http-cst-matchp cst "query") (equal (tree-nonleaf->rulename? cst) (rulename "query"))))
Theorem:
(defthm http-cst-relative-part-rulename (implies (http-cst-matchp cst "relative-part") (equal (tree-nonleaf->rulename? cst) (rulename "relative-part"))))
Theorem:
(defthm http-cst-path-noscheme-rulename (implies (http-cst-matchp cst "path-noscheme") (equal (tree-nonleaf->rulename? cst) (rulename "path-noscheme"))))
Theorem:
(defthm http-cst-scheme-rulename (implies (http-cst-matchp cst "scheme") (equal (tree-nonleaf->rulename? cst) (rulename "scheme"))))
Theorem:
(defthm http-cst-segment-rulename (implies (http-cst-matchp cst "segment") (equal (tree-nonleaf->rulename? cst) (rulename "segment"))))
Theorem:
(defthm http-cst-segment-nz-rulename (implies (http-cst-matchp cst "segment-nz") (equal (tree-nonleaf->rulename? cst) (rulename "segment-nz"))))
Theorem:
(defthm http-cst-segment-nz-nc-rulename (implies (http-cst-matchp cst "segment-nz-nc") (equal (tree-nonleaf->rulename? cst) (rulename "segment-nz-nc"))))
Theorem:
(defthm http-cst-sub-delims-rulename (implies (http-cst-matchp cst "sub-delims") (equal (tree-nonleaf->rulename? cst) (rulename "sub-delims"))))
Theorem:
(defthm http-cst-unreserved-rulename (implies (http-cst-matchp cst "unreserved") (equal (tree-nonleaf->rulename? cst) (rulename "unreserved"))))
Theorem:
(defthm http-cst-uri-host-rulename (implies (http-cst-matchp cst "uri-host") (equal (tree-nonleaf->rulename? cst) (rulename "uri-host"))))
Theorem:
(defthm http-cst-ip-literal-rulename (implies (http-cst-matchp cst "ip-literal") (equal (tree-nonleaf->rulename? cst) (rulename "ip-literal"))))
Theorem:
(defthm http-cst-ipv4address-rulename (implies (http-cst-matchp cst "ipv4address") (equal (tree-nonleaf->rulename? cst) (rulename "ipv4address"))))
Theorem:
(defthm http-cst-dec-octet-rulename (implies (http-cst-matchp cst "dec-octet") (equal (tree-nonleaf->rulename? cst) (rulename "dec-octet"))))
Theorem:
(defthm http-cst-ipv6address-rulename (implies (http-cst-matchp cst "ipv6address") (equal (tree-nonleaf->rulename? cst) (rulename "ipv6address"))))
Theorem:
(defthm http-cst-h16-rulename (implies (http-cst-matchp cst "h16") (equal (tree-nonleaf->rulename? cst) (rulename "h16"))))
Theorem:
(defthm http-cst-ipvfuture-rulename (implies (http-cst-matchp cst "ipvfuture") (equal (tree-nonleaf->rulename? cst) (rulename "ipvfuture"))))
Theorem:
(defthm http-cst-ls32-rulename (implies (http-cst-matchp cst "ls32") (equal (tree-nonleaf->rulename? cst) (rulename "ls32"))))
Theorem:
(defthm http-cst-reg-name-rulename (implies (http-cst-matchp cst "reg-name") (equal (tree-nonleaf->rulename? cst) (rulename "reg-name"))))
Theorem:
(defthm http-cst-userinfo-rulename (implies (http-cst-matchp cst "userinfo") (equal (tree-nonleaf->rulename? cst) (rulename "userinfo"))))
Theorem:
(defthm http-cst-alpha-rulename (implies (http-cst-matchp cst "alpha") (equal (tree-nonleaf->rulename? cst) (rulename "alpha"))))
Theorem:
(defthm http-cst-crlf-rulename (implies (http-cst-matchp cst "crlf") (equal (tree-nonleaf->rulename? cst) (rulename "crlf"))))
Theorem:
(defthm http-cst-cr-rulename (implies (http-cst-matchp cst "cr") (equal (tree-nonleaf->rulename? cst) (rulename "cr"))))
Theorem:
(defthm http-cst-digit-rulename (implies (http-cst-matchp cst "digit") (equal (tree-nonleaf->rulename? cst) (rulename "digit"))))
Theorem:
(defthm http-cst-dquote-rulename (implies (http-cst-matchp cst "dquote") (equal (tree-nonleaf->rulename? cst) (rulename "dquote"))))
Theorem:
(defthm http-cst-hexdig-rulename (implies (http-cst-matchp cst "hexdig") (equal (tree-nonleaf->rulename? cst) (rulename "hexdig"))))
Theorem:
(defthm http-cst-htab-rulename (implies (http-cst-matchp cst "htab") (equal (tree-nonleaf->rulename? cst) (rulename "htab"))))
Theorem:
(defthm http-cst-lf-rulename (implies (http-cst-matchp cst "lf") (equal (tree-nonleaf->rulename? cst) (rulename "lf"))))
Theorem:
(defthm http-cst-octet-rulename (implies (http-cst-matchp cst "octet") (equal (tree-nonleaf->rulename? cst) (rulename "octet"))))
Theorem:
(defthm http-cst-sp-rulename (implies (http-cst-matchp cst "sp") (equal (tree-nonleaf->rulename? cst) (rulename "sp"))))
Theorem:
(defthm http-cst-vchar-rulename (implies (http-cst-matchp cst "vchar") (equal (tree-nonleaf->rulename? cst) (rulename "vchar"))))
Theorem:
(defthm http-cst-bws-branches-match-alt (implies (http-cst-matchp cst "bws") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ows")))
Theorem:
(defthm http-cst-connection-branches-match-alt (implies (http-cst-matchp cst "connection") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \",\" ows ) connection-option *( ows \",\" [ ows connection-option ] )")))
Theorem:
(defthm http-cst-content-length-branches-match-alt (implies (http-cst-matchp cst "content-length") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*digit")))
Theorem:
(defthm http-cst-http-message-branches-match-alt (implies (http-cst-matchp cst "http-message") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "start-line *( header-field crlf ) crlf [ message-body ]")))
Theorem:
(defthm http-cst-http-name-branches-match-alt (implies (http-cst-matchp cst "http-name") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x48.54.54.50")))
Theorem:
(defthm http-cst-http-version-branches-match-alt (implies (http-cst-matchp cst "http-version") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "http-name \"/\" digit \".\" digit")))
Theorem:
(defthm http-cst-host-branches-match-alt (implies (http-cst-matchp cst "host") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "uri-host [ \":\" port ]")))
Theorem:
(defthm http-cst-ows-branches-match-alt (implies (http-cst-matchp cst "ows") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( sp / htab )")))
Theorem:
(defthm http-cst-rws-branches-match-alt (implies (http-cst-matchp cst "rws") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( sp / htab )")))
Theorem:
(defthm http-cst-te-branches-match-alt (implies (http-cst-matchp cst "te") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]")))
Theorem:
(defthm http-cst-trailer-branches-match-alt (implies (http-cst-matchp cst "trailer") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \",\" ows ) field-name *( ows \",\" [ ows field-name ] )")))
Theorem:
(defthm http-cst-transfer-encoding-branches-match-alt (implies (http-cst-matchp cst "transfer-encoding") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \",\" ows ) transfer-coding *( ows \",\" [ ows transfer-coding ] )")))
Theorem:
(defthm http-cst-upgrade-branches-match-alt (implies (http-cst-matchp cst "upgrade") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \",\" ows ) protocol *( ows \",\" [ ows protocol ] )")))
Theorem:
(defthm http-cst-via-branches-match-alt (implies (http-cst-matchp cst "via") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \",\" ows ) ( received-protocol rws received-by [ rws comment ] ) *( ows \",\" [ ows ( received-protocol rws received-by [ rws comment ] ) ] )")))
Theorem:
(defthm http-cst-absolute-form-branches-match-alt (implies (http-cst-matchp cst "absolute-form") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "absolute-uri")))
Theorem:
(defthm http-cst-absolute-path-branches-match-alt (implies (http-cst-matchp cst "absolute-path") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( \"/\" segment )")))
Theorem:
(defthm http-cst-asterisk-form-branches-match-alt (implies (http-cst-matchp cst "asterisk-form") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"*\"")))
Theorem:
(defthm http-cst-authority-form-branches-match-alt (implies (http-cst-matchp cst "authority-form") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "authority")))
Theorem:
(defthm http-cst-chunk-branches-match-alt (implies (http-cst-matchp cst "chunk") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "chunk-size [ chunk-ext ] crlf chunk-data crlf")))
Theorem:
(defthm http-cst-chunk-data-branches-match-alt (implies (http-cst-matchp cst "chunk-data") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*octet")))
Theorem:
(defthm http-cst-chunk-ext-branches-match-alt (implies (http-cst-matchp cst "chunk-ext") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )")))
Theorem:
(defthm http-cst-chunk-ext-name-branches-match-alt (implies (http-cst-matchp cst "chunk-ext-name") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-chunk-ext-val-branches-match-alt (implies (http-cst-matchp cst "chunk-ext-val") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token / quoted-string")))
Theorem:
(defthm http-cst-chunk-size-branches-match-alt (implies (http-cst-matchp cst "chunk-size") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*hexdig")))
Theorem:
(defthm http-cst-chunked-body-branches-match-alt (implies (http-cst-matchp cst "chunked-body") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*chunk last-chunk trailer-part crlf")))
Theorem:
(defthm http-cst-comment-branches-match-alt (implies (http-cst-matchp cst "comment") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"(\" *( ctext / quoted-pair / comment ) \")\"")))
Theorem:
(defthm http-cst-connection-option-branches-match-alt (implies (http-cst-matchp cst "connection-option") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-ctext-branches-match-alt (implies (http-cst-matchp cst "ctext") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "htab / sp / %x21-27 / %x2A-5B / %x5D-7E / obs-text")))
Theorem:
(defthm http-cst-field-content-branches-match-alt (implies (http-cst-matchp cst "field-content") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "field-vchar [ 1*( sp / htab ) field-vchar ]")))
Theorem:
(defthm http-cst-field-name-branches-match-alt (implies (http-cst-matchp cst "field-name") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-field-value-branches-match-alt (implies (http-cst-matchp cst "field-value") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( field-content / obs-fold )")))
Theorem:
(defthm http-cst-field-vchar-branches-match-alt (implies (http-cst-matchp cst "field-vchar") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "vchar / obs-text")))
Theorem:
(defthm http-cst-header-field-branches-match-alt (implies (http-cst-matchp cst "header-field") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "field-name \":\" ows field-value ows")))
Theorem:
(defthm http-cst-http-uri-branches-match-alt (implies (http-cst-matchp cst "http-uri") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"http://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]")))
Theorem:
(defthm http-cst-https-uri-branches-match-alt (implies (http-cst-matchp cst "https-uri") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"https://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]")))
Theorem:
(defthm http-cst-last-chunk-branches-match-alt (implies (http-cst-matchp cst "last-chunk") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*\"0\" [ chunk-ext ] crlf")))
Theorem:
(defthm http-cst-message-body-branches-match-alt (implies (http-cst-matchp cst "message-body") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*octet")))
Theorem:
(defthm http-cst-method-branches-match-alt (implies (http-cst-matchp cst "method") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-obs-fold-branches-match-alt (implies (http-cst-matchp cst "obs-fold") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "crlf 1*( sp / htab )")))
Theorem:
(defthm http-cst-obs-text-branches-match-alt (implies (http-cst-matchp cst "obs-text") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x80-FF")))
Theorem:
(defthm http-cst-origin-form-branches-match-alt (implies (http-cst-matchp cst "origin-form") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "absolute-path [ \"?\" query ]")))
Theorem:
(defthm http-cst-partial-uri-branches-match-alt (implies (http-cst-matchp cst "partial-uri") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "relative-part [ \"?\" query ]")))
Theorem:
(defthm http-cst-protocol-branches-match-alt (implies (http-cst-matchp cst "protocol") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "protocol-name [ \"/\" protocol-version ]")))
Theorem:
(defthm http-cst-protocol-name-branches-match-alt (implies (http-cst-matchp cst "protocol-name") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-protocol-version-branches-match-alt (implies (http-cst-matchp cst "protocol-version") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-pseudonym-branches-match-alt (implies (http-cst-matchp cst "pseudonym") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token")))
Theorem:
(defthm http-cst-qdtext-branches-match-alt (implies (http-cst-matchp cst "qdtext") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "htab / sp / \"!\" / %x23-5B / %x5D-7E / obs-text")))
Theorem:
(defthm http-cst-quoted-pair-branches-match-alt (implies (http-cst-matchp cst "quoted-pair") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"\\\" ( htab / sp / vchar / obs-text )")))
Theorem:
(defthm http-cst-quoted-string-branches-match-alt (implies (http-cst-matchp cst "quoted-string") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dquote *( qdtext / quoted-pair ) dquote")))
Theorem:
(defthm http-cst-rank-branches-match-alt (implies (http-cst-matchp cst "rank") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( \"0\" [ \".\" *3digit ] ) / ( \"1\" [ \".\" *3\"0\" ] )")))
Theorem:
(defthm http-cst-reason-phrase-branches-match-alt (implies (http-cst-matchp cst "reason-phrase") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( htab / sp / vchar / obs-text )")))
Theorem:
(defthm http-cst-received-by-branches-match-alt (implies (http-cst-matchp cst "received-by") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( uri-host [ \":\" port ] ) / pseudonym")))
Theorem:
(defthm http-cst-received-protocol-branches-match-alt (implies (http-cst-matchp cst "received-protocol") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ protocol-name \"/\" ] protocol-version")))
Theorem:
(defthm http-cst-request-line-branches-match-alt (implies (http-cst-matchp cst "request-line") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "method sp request-target sp http-version crlf")))
Theorem:
(defthm http-cst-request-target-branches-match-alt (implies (http-cst-matchp cst "request-target") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "origin-form / absolute-form / authority-form / asterisk-form")))
Theorem:
(defthm http-cst-start-line-branches-match-alt (implies (http-cst-matchp cst "start-line") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "request-line / status-line")))
Theorem:
(defthm http-cst-status-code-branches-match-alt (implies (http-cst-matchp cst "status-code") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "3digit")))
Theorem:
(defthm http-cst-status-line-branches-match-alt (implies (http-cst-matchp cst "status-line") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "http-version sp status-code sp reason-phrase crlf")))
Theorem:
(defthm http-cst-t-codings-branches-match-alt (implies (http-cst-matchp cst "t-codings") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"trailers\" / ( transfer-coding [ t-ranking ] )")))
Theorem:
(defthm http-cst-t-ranking-branches-match-alt (implies (http-cst-matchp cst "t-ranking") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ows \";\" ows \"q=\" rank")))
Theorem:
(defthm http-cst-tchar-branches-match-alt (implies (http-cst-matchp cst "tchar") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\" / digit / alpha")))
Theorem:
(defthm http-cst-token-branches-match-alt (implies (http-cst-matchp cst "token") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*tchar")))
Theorem:
(defthm http-cst-trailer-part-branches-match-alt (implies (http-cst-matchp cst "trailer-part") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( header-field crlf )")))
Theorem:
(defthm http-cst-transfer-coding-branches-match-alt (implies (http-cst-matchp cst "transfer-coding") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"chunked\" / \"compress\" / \"deflate\" / \"gzip\" / transfer-extension")))
Theorem:
(defthm http-cst-transfer-extension-branches-match-alt (implies (http-cst-matchp cst "transfer-extension") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token *( ows \";\" ows transfer-parameter )")))
Theorem:
(defthm http-cst-transfer-parameter-branches-match-alt (implies (http-cst-matchp cst "transfer-parameter") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "token bws \"=\" bws ( token / quoted-string )")))
Theorem:
(defthm http-cst-absolute-uri-branches-match-alt (implies (http-cst-matchp cst "absolute-uri") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "scheme \":\" hier-part [ \"?\" query ]")))
Theorem:
(defthm http-cst-authority-branches-match-alt (implies (http-cst-matchp cst "authority") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ userinfo \"@\" ] uri-host [ \":\" port ]")))
Theorem:
(defthm http-cst-fragment-branches-match-alt (implies (http-cst-matchp cst "fragment") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( pchar / \"/\" / \"?\" )")))
Theorem:
(defthm http-cst-hier-part-branches-match-alt (implies (http-cst-matchp cst "hier-part") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"//\" authority path-abempty / path-absolute / path-rootless / path-empty")))
Theorem:
(defthm http-cst-path-abempty-branches-match-alt (implies (http-cst-matchp cst "path-abempty") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( \"/\" segment )")))
Theorem:
(defthm http-cst-path-absolute-branches-match-alt (implies (http-cst-matchp cst "path-absolute") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"/\" [ segment-nz *( \"/\" segment ) ]")))
Theorem:
(defthm http-cst-path-empty-branches-match-alt (implies (http-cst-matchp cst "path-empty") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "0<pchar>")))
Theorem:
(defthm http-cst-path-rootless-branches-match-alt (implies (http-cst-matchp cst "path-rootless") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "segment-nz *( \"/\" segment )")))
Theorem:
(defthm http-cst-pchar-branches-match-alt (implies (http-cst-matchp cst "pchar") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "unreserved / pct-encoded / sub-delims / \":\" / \"@\"")))
Theorem:
(defthm http-cst-pct-encoded-branches-match-alt (implies (http-cst-matchp cst "pct-encoded") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"%\" hexdig hexdig")))
Theorem:
(defthm http-cst-port-branches-match-alt (implies (http-cst-matchp cst "port") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*digit")))
Theorem:
(defthm http-cst-query-branches-match-alt (implies (http-cst-matchp cst "query") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( pchar / \"/\" / \"?\" )")))
Theorem:
(defthm http-cst-relative-part-branches-match-alt (implies (http-cst-matchp cst "relative-part") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"//\" authority path-abempty / path-absolute / path-noscheme / path-empty")))
Theorem:
(defthm http-cst-path-noscheme-branches-match-alt (implies (http-cst-matchp cst "path-noscheme") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "segment-nz-nc *( \"/\" segment )")))
Theorem:
(defthm http-cst-scheme-branches-match-alt (implies (http-cst-matchp cst "scheme") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha *( alpha / digit / \"+\" / \"-\" / \".\" )")))
Theorem:
(defthm http-cst-segment-branches-match-alt (implies (http-cst-matchp cst "segment") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*pchar")))
Theorem:
(defthm http-cst-segment-nz-branches-match-alt (implies (http-cst-matchp cst "segment-nz") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*pchar")))
Theorem:
(defthm http-cst-segment-nz-nc-branches-match-alt (implies (http-cst-matchp cst "segment-nz-nc") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*( unreserved / pct-encoded / sub-delims / \"@\" )")))
Theorem:
(defthm http-cst-sub-delims-branches-match-alt (implies (http-cst-matchp cst "sub-delims") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\" / \"*\" / \"+\" / \",\" / \";\" / \"=\"")))
Theorem:
(defthm http-cst-unreserved-branches-match-alt (implies (http-cst-matchp cst "unreserved") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "alpha / digit / \"-\" / \".\" / \"_\" / \"~\"")))
Theorem:
(defthm http-cst-uri-host-branches-match-alt (implies (http-cst-matchp cst "uri-host") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "ip-literal / ipv4address / reg-name")))
Theorem:
(defthm http-cst-ip-literal-branches-match-alt (implies (http-cst-matchp cst "ip-literal") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"[\" ( ipv6address / ipvfuture ) \"]\"")))
Theorem:
(defthm http-cst-ipv4address-branches-match-alt (implies (http-cst-matchp cst "ipv4address") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet")))
Theorem:
(defthm http-cst-dec-octet-branches-match-alt (implies (http-cst-matchp cst "dec-octet") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "digit / %x31-39 digit / \"1\" 2digit / \"2\" %x30-34 digit / \"25\" %x30-35")))
Theorem:
(defthm http-cst-ipv6address-branches-match-alt (implies (http-cst-matchp cst "ipv6address") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "6( h16 \":\" ) ls32 / \"::\" 5( h16 \":\" ) ls32 / [ h16 ] \"::\" 4( h16 \":\" ) ls32 / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32 / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32 / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32 / [ *4( h16 \":\" ) h16 ] \"::\" ls32 / [ *5( h16 \":\" ) h16 ] \"::\" h16 / [ *6( h16 \":\" ) h16 ] \"::\"")))
Theorem:
(defthm http-cst-h16-branches-match-alt (implies (http-cst-matchp cst "h16") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "1*4hexdig")))
Theorem:
(defthm http-cst-ipvfuture-branches-match-alt (implies (http-cst-matchp cst "ipvfuture") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "\"v\" 1*hexdig \".\" 1*( unreserved / sub-delims / \":\" )")))
Theorem:
(defthm http-cst-ls32-branches-match-alt (implies (http-cst-matchp cst "ls32") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( h16 \":\" h16 ) / ipv4address")))
Theorem:
(defthm http-cst-reg-name-branches-match-alt (implies (http-cst-matchp cst "reg-name") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( unreserved / pct-encoded / sub-delims )")))
Theorem:
(defthm http-cst-userinfo-branches-match-alt (implies (http-cst-matchp cst "userinfo") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( unreserved / pct-encoded / sub-delims / \":\" )")))
Theorem:
(defthm http-cst-alpha-branches-match-alt (implies (http-cst-matchp cst "alpha") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x41-5A / %x61-7A")))
Theorem:
(defthm http-cst-crlf-branches-match-alt (implies (http-cst-matchp cst "crlf") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "cr lf")))
Theorem:
(defthm http-cst-cr-branches-match-alt (implies (http-cst-matchp cst "cr") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xD")))
Theorem:
(defthm http-cst-digit-branches-match-alt (implies (http-cst-matchp cst "digit") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30-39")))
Theorem:
(defthm http-cst-dquote-branches-match-alt (implies (http-cst-matchp cst "dquote") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x22")))
Theorem:
(defthm http-cst-hexdig-branches-match-alt (implies (http-cst-matchp cst "hexdig") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"")))
Theorem:
(defthm http-cst-htab-branches-match-alt (implies (http-cst-matchp cst "htab") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x9")))
Theorem:
(defthm http-cst-lf-branches-match-alt (implies (http-cst-matchp cst "lf") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%xA")))
Theorem:
(defthm http-cst-octet-branches-match-alt (implies (http-cst-matchp cst "octet") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x0-FF")))
Theorem:
(defthm http-cst-sp-branches-match-alt (implies (http-cst-matchp cst "sp") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20")))
Theorem:
(defthm http-cst-vchar-branches-match-alt (implies (http-cst-matchp cst "vchar") (http-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x21-7E")))
Theorem:
(defthm http-cst-bws-concs (implies (http-cst-list-list-alt-matchp cstss "ows") (or (http-cst-list-list-conc-matchp cstss "ows"))))
Theorem:
(defthm http-cst-connection-concs (implies (http-cst-list-list-alt-matchp cstss "*( \",\" ows ) connection-option *( ows \",\" [ ows connection-option ] )") (or (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) connection-option *( ows \",\" [ ows connection-option ] )"))))
Theorem:
(defthm http-cst-content-length-concs (implies (http-cst-list-list-alt-matchp cstss "1*digit") (or (http-cst-list-list-conc-matchp cstss "1*digit"))))
Theorem:
(defthm http-cst-http-message-concs (implies (http-cst-list-list-alt-matchp cstss "start-line *( header-field crlf ) crlf [ message-body ]") (or (http-cst-list-list-conc-matchp cstss "start-line *( header-field crlf ) crlf [ message-body ]"))))
Theorem:
(defthm http-cst-http-name-concs (implies (http-cst-list-list-alt-matchp cstss "%x48.54.54.50") (or (http-cst-list-list-conc-matchp cstss "%x48.54.54.50"))))
Theorem:
(defthm http-cst-http-version-concs (implies (http-cst-list-list-alt-matchp cstss "http-name \"/\" digit \".\" digit") (or (http-cst-list-list-conc-matchp cstss "http-name \"/\" digit \".\" digit"))))
Theorem:
(defthm http-cst-host-concs (implies (http-cst-list-list-alt-matchp cstss "uri-host [ \":\" port ]") (or (http-cst-list-list-conc-matchp cstss "uri-host [ \":\" port ]"))))
Theorem:
(defthm http-cst-ows-concs (implies (http-cst-list-list-alt-matchp cstss "*( sp / htab )") (or (http-cst-list-list-conc-matchp cstss "*( sp / htab )"))))
Theorem:
(defthm http-cst-rws-concs (implies (http-cst-list-list-alt-matchp cstss "1*( sp / htab )") (or (http-cst-list-list-conc-matchp cstss "1*( sp / htab )"))))
Theorem:
(defthm http-cst-te-concs (implies (http-cst-list-list-alt-matchp cstss "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]") (or (http-cst-list-list-conc-matchp cstss "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))))
Theorem:
(defthm http-cst-trailer-concs (implies (http-cst-list-list-alt-matchp cstss "*( \",\" ows ) field-name *( ows \",\" [ ows field-name ] )") (or (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) field-name *( ows \",\" [ ows field-name ] )"))))
Theorem:
(defthm http-cst-transfer-encoding-concs (implies (http-cst-list-list-alt-matchp cstss "*( \",\" ows ) transfer-coding *( ows \",\" [ ows transfer-coding ] )") (or (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) transfer-coding *( ows \",\" [ ows transfer-coding ] )"))))
Theorem:
(defthm http-cst-upgrade-concs (implies (http-cst-list-list-alt-matchp cstss "*( \",\" ows ) protocol *( ows \",\" [ ows protocol ] )") (or (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) protocol *( ows \",\" [ ows protocol ] )"))))
Theorem:
(defthm http-cst-via-concs (implies (http-cst-list-list-alt-matchp cstss "*( \",\" ows ) ( received-protocol rws received-by [ rws comment ] ) *( ows \",\" [ ows ( received-protocol rws received-by [ rws comment ] ) ] )") (or (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) ( received-protocol rws received-by [ rws comment ] ) *( ows \",\" [ ows ( received-protocol rws received-by [ rws comment ] ) ] )"))))
Theorem:
(defthm http-cst-absolute-form-concs (implies (http-cst-list-list-alt-matchp cstss "absolute-uri") (or (http-cst-list-list-conc-matchp cstss "absolute-uri"))))
Theorem:
(defthm http-cst-absolute-path-concs (implies (http-cst-list-list-alt-matchp cstss "1*( \"/\" segment )") (or (http-cst-list-list-conc-matchp cstss "1*( \"/\" segment )"))))
Theorem:
(defthm http-cst-asterisk-form-concs (implies (http-cst-list-list-alt-matchp cstss "\"*\"") (or (http-cst-list-list-conc-matchp cstss "\"*\""))))
Theorem:
(defthm http-cst-authority-form-concs (implies (http-cst-list-list-alt-matchp cstss "authority") (or (http-cst-list-list-conc-matchp cstss "authority"))))
Theorem:
(defthm http-cst-chunk-concs (implies (http-cst-list-list-alt-matchp cstss "chunk-size [ chunk-ext ] crlf chunk-data crlf") (or (http-cst-list-list-conc-matchp cstss "chunk-size [ chunk-ext ] crlf chunk-data crlf"))))
Theorem:
(defthm http-cst-chunk-data-concs (implies (http-cst-list-list-alt-matchp cstss "1*octet") (or (http-cst-list-list-conc-matchp cstss "1*octet"))))
Theorem:
(defthm http-cst-chunk-ext-concs (implies (http-cst-list-list-alt-matchp cstss "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )") (or (http-cst-list-list-conc-matchp cstss "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )"))))
Theorem:
(defthm http-cst-chunk-ext-name-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-concs (implies (http-cst-list-list-alt-matchp cstss "token / quoted-string") (or (http-cst-list-list-conc-matchp cstss "token") (http-cst-list-list-conc-matchp cstss "quoted-string"))))
Theorem:
(defthm http-cst-chunk-size-concs (implies (http-cst-list-list-alt-matchp cstss "1*hexdig") (or (http-cst-list-list-conc-matchp cstss "1*hexdig"))))
Theorem:
(defthm http-cst-chunked-body-concs (implies (http-cst-list-list-alt-matchp cstss "*chunk last-chunk trailer-part crlf") (or (http-cst-list-list-conc-matchp cstss "*chunk last-chunk trailer-part crlf"))))
Theorem:
(defthm http-cst-comment-concs (implies (http-cst-list-list-alt-matchp cstss "\"(\" *( ctext / quoted-pair / comment ) \")\"") (or (http-cst-list-list-conc-matchp cstss "\"(\" *( ctext / quoted-pair / comment ) \")\""))))
Theorem:
(defthm http-cst-connection-option-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-ctext-concs (implies (http-cst-list-list-alt-matchp cstss "htab / sp / %x21-27 / %x2A-5B / %x5D-7E / obs-text") (or (http-cst-list-list-conc-matchp cstss "htab") (http-cst-list-list-conc-matchp cstss "sp") (http-cst-list-list-conc-matchp cstss "%x21-27") (http-cst-list-list-conc-matchp cstss "%x2A-5B") (http-cst-list-list-conc-matchp cstss "%x5D-7E") (http-cst-list-list-conc-matchp cstss "obs-text"))))
Theorem:
(defthm http-cst-field-content-concs (implies (http-cst-list-list-alt-matchp cstss "field-vchar [ 1*( sp / htab ) field-vchar ]") (or (http-cst-list-list-conc-matchp cstss "field-vchar [ 1*( sp / htab ) field-vchar ]"))))
Theorem:
(defthm http-cst-field-name-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-field-value-concs (implies (http-cst-list-list-alt-matchp cstss "*( field-content / obs-fold )") (or (http-cst-list-list-conc-matchp cstss "*( field-content / obs-fold )"))))
Theorem:
(defthm http-cst-field-vchar-concs (implies (http-cst-list-list-alt-matchp cstss "vchar / obs-text") (or (http-cst-list-list-conc-matchp cstss "vchar") (http-cst-list-list-conc-matchp cstss "obs-text"))))
Theorem:
(defthm http-cst-header-field-concs (implies (http-cst-list-list-alt-matchp cstss "field-name \":\" ows field-value ows") (or (http-cst-list-list-conc-matchp cstss "field-name \":\" ows field-value ows"))))
Theorem:
(defthm http-cst-http-uri-concs (implies (http-cst-list-list-alt-matchp cstss "\"http://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]") (or (http-cst-list-list-conc-matchp cstss "\"http://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]"))))
Theorem:
(defthm http-cst-https-uri-concs (implies (http-cst-list-list-alt-matchp cstss "\"https://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]") (or (http-cst-list-list-conc-matchp cstss "\"https://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]"))))
Theorem:
(defthm http-cst-last-chunk-concs (implies (http-cst-list-list-alt-matchp cstss "1*\"0\" [ chunk-ext ] crlf") (or (http-cst-list-list-conc-matchp cstss "1*\"0\" [ chunk-ext ] crlf"))))
Theorem:
(defthm http-cst-message-body-concs (implies (http-cst-list-list-alt-matchp cstss "*octet") (or (http-cst-list-list-conc-matchp cstss "*octet"))))
Theorem:
(defthm http-cst-method-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-obs-fold-concs (implies (http-cst-list-list-alt-matchp cstss "crlf 1*( sp / htab )") (or (http-cst-list-list-conc-matchp cstss "crlf 1*( sp / htab )"))))
Theorem:
(defthm http-cst-obs-text-concs (implies (http-cst-list-list-alt-matchp cstss "%x80-FF") (or (http-cst-list-list-conc-matchp cstss "%x80-FF"))))
Theorem:
(defthm http-cst-origin-form-concs (implies (http-cst-list-list-alt-matchp cstss "absolute-path [ \"?\" query ]") (or (http-cst-list-list-conc-matchp cstss "absolute-path [ \"?\" query ]"))))
Theorem:
(defthm http-cst-partial-uri-concs (implies (http-cst-list-list-alt-matchp cstss "relative-part [ \"?\" query ]") (or (http-cst-list-list-conc-matchp cstss "relative-part [ \"?\" query ]"))))
Theorem:
(defthm http-cst-protocol-concs (implies (http-cst-list-list-alt-matchp cstss "protocol-name [ \"/\" protocol-version ]") (or (http-cst-list-list-conc-matchp cstss "protocol-name [ \"/\" protocol-version ]"))))
Theorem:
(defthm http-cst-protocol-name-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-protocol-version-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-pseudonym-concs (implies (http-cst-list-list-alt-matchp cstss "token") (or (http-cst-list-list-conc-matchp cstss "token"))))
Theorem:
(defthm http-cst-qdtext-concs (implies (http-cst-list-list-alt-matchp cstss "htab / sp / \"!\" / %x23-5B / %x5D-7E / obs-text") (or (http-cst-list-list-conc-matchp cstss "htab") (http-cst-list-list-conc-matchp cstss "sp") (http-cst-list-list-conc-matchp cstss "\"!\"") (http-cst-list-list-conc-matchp cstss "%x23-5B") (http-cst-list-list-conc-matchp cstss "%x5D-7E") (http-cst-list-list-conc-matchp cstss "obs-text"))))
Theorem:
(defthm http-cst-quoted-pair-concs (implies (http-cst-list-list-alt-matchp cstss "\"\\\" ( htab / sp / vchar / obs-text )") (or (http-cst-list-list-conc-matchp cstss "\"\\\" ( htab / sp / vchar / obs-text )"))))
Theorem:
(defthm http-cst-quoted-string-concs (implies (http-cst-list-list-alt-matchp cstss "dquote *( qdtext / quoted-pair ) dquote") (or (http-cst-list-list-conc-matchp cstss "dquote *( qdtext / quoted-pair ) dquote"))))
Theorem:
(defthm http-cst-rank-concs (implies (http-cst-list-list-alt-matchp cstss "( \"0\" [ \".\" *3digit ] ) / ( \"1\" [ \".\" *3\"0\" ] )") (or (http-cst-list-list-conc-matchp cstss "( \"0\" [ \".\" *3digit ] )") (http-cst-list-list-conc-matchp cstss "( \"1\" [ \".\" *3\"0\" ] )"))))
Theorem:
(defthm http-cst-reason-phrase-concs (implies (http-cst-list-list-alt-matchp cstss "*( htab / sp / vchar / obs-text )") (or (http-cst-list-list-conc-matchp cstss "*( htab / sp / vchar / obs-text )"))))
Theorem:
(defthm http-cst-received-by-concs (implies (http-cst-list-list-alt-matchp cstss "( uri-host [ \":\" port ] ) / pseudonym") (or (http-cst-list-list-conc-matchp cstss "( uri-host [ \":\" port ] )") (http-cst-list-list-conc-matchp cstss "pseudonym"))))
Theorem:
(defthm http-cst-received-protocol-concs (implies (http-cst-list-list-alt-matchp cstss "[ protocol-name \"/\" ] protocol-version") (or (http-cst-list-list-conc-matchp cstss "[ protocol-name \"/\" ] protocol-version"))))
Theorem:
(defthm http-cst-request-line-concs (implies (http-cst-list-list-alt-matchp cstss "method sp request-target sp http-version crlf") (or (http-cst-list-list-conc-matchp cstss "method sp request-target sp http-version crlf"))))
Theorem:
(defthm http-cst-request-target-concs (implies (http-cst-list-list-alt-matchp cstss "origin-form / absolute-form / authority-form / asterisk-form") (or (http-cst-list-list-conc-matchp cstss "origin-form") (http-cst-list-list-conc-matchp cstss "absolute-form") (http-cst-list-list-conc-matchp cstss "authority-form") (http-cst-list-list-conc-matchp cstss "asterisk-form"))))
Theorem:
(defthm http-cst-start-line-concs (implies (http-cst-list-list-alt-matchp cstss "request-line / status-line") (or (http-cst-list-list-conc-matchp cstss "request-line") (http-cst-list-list-conc-matchp cstss "status-line"))))
Theorem:
(defthm http-cst-status-code-concs (implies (http-cst-list-list-alt-matchp cstss "3digit") (or (http-cst-list-list-conc-matchp cstss "3digit"))))
Theorem:
(defthm http-cst-status-line-concs (implies (http-cst-list-list-alt-matchp cstss "http-version sp status-code sp reason-phrase crlf") (or (http-cst-list-list-conc-matchp cstss "http-version sp status-code sp reason-phrase crlf"))))
Theorem:
(defthm http-cst-t-codings-concs (implies (http-cst-list-list-alt-matchp cstss "\"trailers\" / ( transfer-coding [ t-ranking ] )") (or (http-cst-list-list-conc-matchp cstss "\"trailers\"") (http-cst-list-list-conc-matchp cstss "( transfer-coding [ t-ranking ] )"))))
Theorem:
(defthm http-cst-t-ranking-concs (implies (http-cst-list-list-alt-matchp cstss "ows \";\" ows \"q=\" rank") (or (http-cst-list-list-conc-matchp cstss "ows \";\" ows \"q=\" rank"))))
Theorem:
(defthm http-cst-tchar-concs (implies (http-cst-list-list-alt-matchp cstss "\"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\" / digit / alpha") (or (http-cst-list-list-conc-matchp cstss "\"!\"") (http-cst-list-list-conc-matchp cstss "\"#\"") (http-cst-list-list-conc-matchp cstss "\"$\"") (http-cst-list-list-conc-matchp cstss "\"%\"") (http-cst-list-list-conc-matchp cstss "\"&\"") (http-cst-list-list-conc-matchp cstss "\"'\"") (http-cst-list-list-conc-matchp cstss "\"*\"") (http-cst-list-list-conc-matchp cstss "\"+\"") (http-cst-list-list-conc-matchp cstss "\"-\"") (http-cst-list-list-conc-matchp cstss "\".\"") (http-cst-list-list-conc-matchp cstss "\"^\"") (http-cst-list-list-conc-matchp cstss "\"_\"") (http-cst-list-list-conc-matchp cstss "\"`\"") (http-cst-list-list-conc-matchp cstss "\"|\"") (http-cst-list-list-conc-matchp cstss "\"~\"") (http-cst-list-list-conc-matchp cstss "digit") (http-cst-list-list-conc-matchp cstss "alpha"))))
Theorem:
(defthm http-cst-token-concs (implies (http-cst-list-list-alt-matchp cstss "1*tchar") (or (http-cst-list-list-conc-matchp cstss "1*tchar"))))
Theorem:
(defthm http-cst-trailer-part-concs (implies (http-cst-list-list-alt-matchp cstss "*( header-field crlf )") (or (http-cst-list-list-conc-matchp cstss "*( header-field crlf )"))))
Theorem:
(defthm http-cst-transfer-coding-concs (implies (http-cst-list-list-alt-matchp cstss "\"chunked\" / \"compress\" / \"deflate\" / \"gzip\" / transfer-extension") (or (http-cst-list-list-conc-matchp cstss "\"chunked\"") (http-cst-list-list-conc-matchp cstss "\"compress\"") (http-cst-list-list-conc-matchp cstss "\"deflate\"") (http-cst-list-list-conc-matchp cstss "\"gzip\"") (http-cst-list-list-conc-matchp cstss "transfer-extension"))))
Theorem:
(defthm http-cst-transfer-extension-concs (implies (http-cst-list-list-alt-matchp cstss "token *( ows \";\" ows transfer-parameter )") (or (http-cst-list-list-conc-matchp cstss "token *( ows \";\" ows transfer-parameter )"))))
Theorem:
(defthm http-cst-transfer-parameter-concs (implies (http-cst-list-list-alt-matchp cstss "token bws \"=\" bws ( token / quoted-string )") (or (http-cst-list-list-conc-matchp cstss "token bws \"=\" bws ( token / quoted-string )"))))
Theorem:
(defthm http-cst-absolute-uri-concs (implies (http-cst-list-list-alt-matchp cstss "scheme \":\" hier-part [ \"?\" query ]") (or (http-cst-list-list-conc-matchp cstss "scheme \":\" hier-part [ \"?\" query ]"))))
Theorem:
(defthm http-cst-authority-concs (implies (http-cst-list-list-alt-matchp cstss "[ userinfo \"@\" ] uri-host [ \":\" port ]") (or (http-cst-list-list-conc-matchp cstss "[ userinfo \"@\" ] uri-host [ \":\" port ]"))))
Theorem:
(defthm http-cst-fragment-concs (implies (http-cst-list-list-alt-matchp cstss "*( pchar / \"/\" / \"?\" )") (or (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )"))))
Theorem:
(defthm http-cst-hier-part-concs (implies (http-cst-list-list-alt-matchp cstss "\"//\" authority path-abempty / path-absolute / path-rootless / path-empty") (or (http-cst-list-list-conc-matchp cstss "\"//\" authority path-abempty") (http-cst-list-list-conc-matchp cstss "path-absolute") (http-cst-list-list-conc-matchp cstss "path-rootless") (http-cst-list-list-conc-matchp cstss "path-empty"))))
Theorem:
(defthm http-cst-path-abempty-concs (implies (http-cst-list-list-alt-matchp cstss "*( \"/\" segment )") (or (http-cst-list-list-conc-matchp cstss "*( \"/\" segment )"))))
Theorem:
(defthm http-cst-path-absolute-concs (implies (http-cst-list-list-alt-matchp cstss "\"/\" [ segment-nz *( \"/\" segment ) ]") (or (http-cst-list-list-conc-matchp cstss "\"/\" [ segment-nz *( \"/\" segment ) ]"))))
Theorem:
(defthm http-cst-path-empty-concs (implies (http-cst-list-list-alt-matchp cstss "0<pchar>") (or (http-cst-list-list-conc-matchp cstss "0<pchar>"))))
Theorem:
(defthm http-cst-path-rootless-concs (implies (http-cst-list-list-alt-matchp cstss "segment-nz *( \"/\" segment )") (or (http-cst-list-list-conc-matchp cstss "segment-nz *( \"/\" segment )"))))
Theorem:
(defthm http-cst-pchar-concs (implies (http-cst-list-list-alt-matchp cstss "unreserved / pct-encoded / sub-delims / \":\" / \"@\"") (or (http-cst-list-list-conc-matchp cstss "unreserved") (http-cst-list-list-conc-matchp cstss "pct-encoded") (http-cst-list-list-conc-matchp cstss "sub-delims") (http-cst-list-list-conc-matchp cstss "\":\"") (http-cst-list-list-conc-matchp cstss "\"@\""))))
Theorem:
(defthm http-cst-pct-encoded-concs (implies (http-cst-list-list-alt-matchp cstss "\"%\" hexdig hexdig") (or (http-cst-list-list-conc-matchp cstss "\"%\" hexdig hexdig"))))
Theorem:
(defthm http-cst-port-concs (implies (http-cst-list-list-alt-matchp cstss "*digit") (or (http-cst-list-list-conc-matchp cstss "*digit"))))
Theorem:
(defthm http-cst-query-concs (implies (http-cst-list-list-alt-matchp cstss "*( pchar / \"/\" / \"?\" )") (or (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )"))))
Theorem:
(defthm http-cst-relative-part-concs (implies (http-cst-list-list-alt-matchp cstss "\"//\" authority path-abempty / path-absolute / path-noscheme / path-empty") (or (http-cst-list-list-conc-matchp cstss "\"//\" authority path-abempty") (http-cst-list-list-conc-matchp cstss "path-absolute") (http-cst-list-list-conc-matchp cstss "path-noscheme") (http-cst-list-list-conc-matchp cstss "path-empty"))))
Theorem:
(defthm http-cst-path-noscheme-concs (implies (http-cst-list-list-alt-matchp cstss "segment-nz-nc *( \"/\" segment )") (or (http-cst-list-list-conc-matchp cstss "segment-nz-nc *( \"/\" segment )"))))
Theorem:
(defthm http-cst-scheme-concs (implies (http-cst-list-list-alt-matchp cstss "alpha *( alpha / digit / \"+\" / \"-\" / \".\" )") (or (http-cst-list-list-conc-matchp cstss "alpha *( alpha / digit / \"+\" / \"-\" / \".\" )"))))
Theorem:
(defthm http-cst-segment-concs (implies (http-cst-list-list-alt-matchp cstss "*pchar") (or (http-cst-list-list-conc-matchp cstss "*pchar"))))
Theorem:
(defthm http-cst-segment-nz-concs (implies (http-cst-list-list-alt-matchp cstss "1*pchar") (or (http-cst-list-list-conc-matchp cstss "1*pchar"))))
Theorem:
(defthm http-cst-segment-nz-nc-concs (implies (http-cst-list-list-alt-matchp cstss "1*( unreserved / pct-encoded / sub-delims / \"@\" )") (or (http-cst-list-list-conc-matchp cstss "1*( unreserved / pct-encoded / sub-delims / \"@\" )"))))
Theorem:
(defthm http-cst-sub-delims-concs (implies (http-cst-list-list-alt-matchp cstss "\"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\" / \"*\" / \"+\" / \",\" / \";\" / \"=\"") (or (http-cst-list-list-conc-matchp cstss "\"!\"") (http-cst-list-list-conc-matchp cstss "\"$\"") (http-cst-list-list-conc-matchp cstss "\"&\"") (http-cst-list-list-conc-matchp cstss "\"'\"") (http-cst-list-list-conc-matchp cstss "\"(\"") (http-cst-list-list-conc-matchp cstss "\")\"") (http-cst-list-list-conc-matchp cstss "\"*\"") (http-cst-list-list-conc-matchp cstss "\"+\"") (http-cst-list-list-conc-matchp cstss "\",\"") (http-cst-list-list-conc-matchp cstss "\";\"") (http-cst-list-list-conc-matchp cstss "\"=\""))))
Theorem:
(defthm http-cst-unreserved-concs (implies (http-cst-list-list-alt-matchp cstss "alpha / digit / \"-\" / \".\" / \"_\" / \"~\"") (or (http-cst-list-list-conc-matchp cstss "alpha") (http-cst-list-list-conc-matchp cstss "digit") (http-cst-list-list-conc-matchp cstss "\"-\"") (http-cst-list-list-conc-matchp cstss "\".\"") (http-cst-list-list-conc-matchp cstss "\"_\"") (http-cst-list-list-conc-matchp cstss "\"~\""))))
Theorem:
(defthm http-cst-uri-host-concs (implies (http-cst-list-list-alt-matchp cstss "ip-literal / ipv4address / reg-name") (or (http-cst-list-list-conc-matchp cstss "ip-literal") (http-cst-list-list-conc-matchp cstss "ipv4address") (http-cst-list-list-conc-matchp cstss "reg-name"))))
Theorem:
(defthm http-cst-ip-literal-concs (implies (http-cst-list-list-alt-matchp cstss "\"[\" ( ipv6address / ipvfuture ) \"]\"") (or (http-cst-list-list-conc-matchp cstss "\"[\" ( ipv6address / ipvfuture ) \"]\""))))
Theorem:
(defthm http-cst-ipv4address-concs (implies (http-cst-list-list-alt-matchp cstss "dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet") (or (http-cst-list-list-conc-matchp cstss "dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet"))))
Theorem:
(defthm http-cst-dec-octet-concs (implies (http-cst-list-list-alt-matchp cstss "digit / %x31-39 digit / \"1\" 2digit / \"2\" %x30-34 digit / \"25\" %x30-35") (or (http-cst-list-list-conc-matchp cstss "digit") (http-cst-list-list-conc-matchp cstss "%x31-39 digit") (http-cst-list-list-conc-matchp cstss "\"1\" 2digit") (http-cst-list-list-conc-matchp cstss "\"2\" %x30-34 digit") (http-cst-list-list-conc-matchp cstss "\"25\" %x30-35"))))
Theorem:
(defthm http-cst-ipv6address-concs (implies (http-cst-list-list-alt-matchp cstss "6( h16 \":\" ) ls32 / \"::\" 5( h16 \":\" ) ls32 / [ h16 ] \"::\" 4( h16 \":\" ) ls32 / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32 / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32 / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32 / [ *4( h16 \":\" ) h16 ] \"::\" ls32 / [ *5( h16 \":\" ) h16 ] \"::\" h16 / [ *6( h16 \":\" ) h16 ] \"::\"") (or (http-cst-list-list-conc-matchp cstss "6( h16 \":\" ) ls32") (http-cst-list-list-conc-matchp cstss "\"::\" 5( h16 \":\" ) ls32") (http-cst-list-list-conc-matchp cstss "[ h16 ] \"::\" 4( h16 \":\" ) ls32") (http-cst-list-list-conc-matchp cstss "[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32") (http-cst-list-list-conc-matchp cstss "[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32") (http-cst-list-list-conc-matchp cstss "[ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32") (http-cst-list-list-conc-matchp cstss "[ *4( h16 \":\" ) h16 ] \"::\" ls32") (http-cst-list-list-conc-matchp cstss "[ *5( h16 \":\" ) h16 ] \"::\" h16") (http-cst-list-list-conc-matchp cstss "[ *6( h16 \":\" ) h16 ] \"::\""))))
Theorem:
(defthm http-cst-h16-concs (implies (http-cst-list-list-alt-matchp cstss "1*4hexdig") (or (http-cst-list-list-conc-matchp cstss "1*4hexdig"))))
Theorem:
(defthm http-cst-ipvfuture-concs (implies (http-cst-list-list-alt-matchp cstss "\"v\" 1*hexdig \".\" 1*( unreserved / sub-delims / \":\" )") (or (http-cst-list-list-conc-matchp cstss "\"v\" 1*hexdig \".\" 1*( unreserved / sub-delims / \":\" )"))))
Theorem:
(defthm http-cst-ls32-concs (implies (http-cst-list-list-alt-matchp cstss "( h16 \":\" h16 ) / ipv4address") (or (http-cst-list-list-conc-matchp cstss "( h16 \":\" h16 )") (http-cst-list-list-conc-matchp cstss "ipv4address"))))
Theorem:
(defthm http-cst-reg-name-concs (implies (http-cst-list-list-alt-matchp cstss "*( unreserved / pct-encoded / sub-delims )") (or (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims )"))))
Theorem:
(defthm http-cst-userinfo-concs (implies (http-cst-list-list-alt-matchp cstss "*( unreserved / pct-encoded / sub-delims / \":\" )") (or (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims / \":\" )"))))
Theorem:
(defthm http-cst-alpha-concs (implies (http-cst-list-list-alt-matchp cstss "%x41-5A / %x61-7A") (or (http-cst-list-list-conc-matchp cstss "%x41-5A") (http-cst-list-list-conc-matchp cstss "%x61-7A"))))
Theorem:
(defthm http-cst-crlf-concs (implies (http-cst-list-list-alt-matchp cstss "cr lf") (or (http-cst-list-list-conc-matchp cstss "cr lf"))))
Theorem:
(defthm http-cst-cr-concs (implies (http-cst-list-list-alt-matchp cstss "%xD") (or (http-cst-list-list-conc-matchp cstss "%xD"))))
Theorem:
(defthm http-cst-digit-concs (implies (http-cst-list-list-alt-matchp cstss "%x30-39") (or (http-cst-list-list-conc-matchp cstss "%x30-39"))))
Theorem:
(defthm http-cst-dquote-concs (implies (http-cst-list-list-alt-matchp cstss "%x22") (or (http-cst-list-list-conc-matchp cstss "%x22"))))
Theorem:
(defthm http-cst-hexdig-concs (implies (http-cst-list-list-alt-matchp cstss "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"") (or (http-cst-list-list-conc-matchp cstss "digit") (http-cst-list-list-conc-matchp cstss "\"A\"") (http-cst-list-list-conc-matchp cstss "\"B\"") (http-cst-list-list-conc-matchp cstss "\"C\"") (http-cst-list-list-conc-matchp cstss "\"D\"") (http-cst-list-list-conc-matchp cstss "\"E\"") (http-cst-list-list-conc-matchp cstss "\"F\""))))
Theorem:
(defthm http-cst-htab-concs (implies (http-cst-list-list-alt-matchp cstss "%x9") (or (http-cst-list-list-conc-matchp cstss "%x9"))))
Theorem:
(defthm http-cst-lf-concs (implies (http-cst-list-list-alt-matchp cstss "%xA") (or (http-cst-list-list-conc-matchp cstss "%xA"))))
Theorem:
(defthm http-cst-octet-concs (implies (http-cst-list-list-alt-matchp cstss "%x0-FF") (or (http-cst-list-list-conc-matchp cstss "%x0-FF"))))
Theorem:
(defthm http-cst-sp-concs (implies (http-cst-list-list-alt-matchp cstss "%x20") (or (http-cst-list-list-conc-matchp cstss "%x20"))))
Theorem:
(defthm http-cst-vchar-concs (implies (http-cst-list-list-alt-matchp cstss "%x21-7E") (or (http-cst-list-list-conc-matchp cstss "%x21-7E"))))
Theorem:
(defthm http-cst-bws-conc-matching (implies (http-cst-list-list-conc-matchp cstss "ows") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "ows"))))
Theorem:
(defthm http-cst-content-length-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*digit"))))
Theorem:
(defthm http-cst-http-name-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x48.54.54.50") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x48.54.54.50"))))
Theorem:
(defthm http-cst-ows-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( sp / htab )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( sp / htab )"))))
Theorem:
(defthm http-cst-rws-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*( sp / htab )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*( sp / htab )"))))
Theorem:
(defthm http-cst-te-conc-matching (implies (http-cst-list-list-conc-matchp cstss "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))))
Theorem:
(defthm http-cst-absolute-form-conc-matching (implies (http-cst-list-list-conc-matchp cstss "absolute-uri") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "absolute-uri"))))
Theorem:
(defthm http-cst-absolute-path-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*( \"/\" segment )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*( \"/\" segment )"))))
Theorem:
(defthm http-cst-asterisk-form-conc-matching (implies (http-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm http-cst-authority-form-conc-matching (implies (http-cst-list-list-conc-matchp cstss "authority") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "authority"))))
Theorem:
(defthm http-cst-chunk-data-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*octet") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*octet"))))
Theorem:
(defthm http-cst-chunk-ext-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )"))))
Theorem:
(defthm http-cst-chunk-ext-name-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "quoted-string") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "quoted-string"))))
Theorem:
(defthm http-cst-chunk-size-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*hexdig") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*hexdig"))))
Theorem:
(defthm http-cst-connection-option-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-ctext-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "htab") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "htab"))))
Theorem:
(defthm http-cst-ctext-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "sp") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "sp"))))
Theorem:
(defthm http-cst-ctext-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "%x21-27") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x21-27"))))
Theorem:
(defthm http-cst-ctext-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "%x2A-5B") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x2A-5B"))))
Theorem:
(defthm http-cst-ctext-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "%x5D-7E") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x5D-7E"))))
Theorem:
(defthm http-cst-ctext-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "obs-text") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "obs-text"))))
Theorem:
(defthm http-cst-field-name-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-field-value-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( field-content / obs-fold )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( field-content / obs-fold )"))))
Theorem:
(defthm http-cst-field-vchar-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "vchar") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "vchar"))))
Theorem:
(defthm http-cst-field-vchar-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "obs-text") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "obs-text"))))
Theorem:
(defthm http-cst-message-body-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*octet") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*octet"))))
Theorem:
(defthm http-cst-method-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-obs-text-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x80-FF") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x80-FF"))))
Theorem:
(defthm http-cst-protocol-name-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-protocol-version-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-pseudonym-conc-matching (implies (http-cst-list-list-conc-matchp cstss "token") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "token"))))
Theorem:
(defthm http-cst-qdtext-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "htab") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "htab"))))
Theorem:
(defthm http-cst-qdtext-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "sp") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "sp"))))
Theorem:
(defthm http-cst-qdtext-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"!\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"!\""))))
Theorem:
(defthm http-cst-qdtext-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "%x23-5B") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x23-5B"))))
Theorem:
(defthm http-cst-qdtext-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "%x5D-7E") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x5D-7E"))))
Theorem:
(defthm http-cst-qdtext-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "obs-text") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "obs-text"))))
Theorem:
(defthm http-cst-rank-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "( \"0\" [ \".\" *3digit ] )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "( \"0\" [ \".\" *3digit ] )"))))
Theorem:
(defthm http-cst-rank-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "( \"1\" [ \".\" *3\"0\" ] )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "( \"1\" [ \".\" *3\"0\" ] )"))))
Theorem:
(defthm http-cst-reason-phrase-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( htab / sp / vchar / obs-text )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( htab / sp / vchar / obs-text )"))))
Theorem:
(defthm http-cst-received-by-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "( uri-host [ \":\" port ] )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "( uri-host [ \":\" port ] )"))))
Theorem:
(defthm http-cst-received-by-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "pseudonym") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "pseudonym"))))
Theorem:
(defthm http-cst-request-target-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "origin-form") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "origin-form"))))
Theorem:
(defthm http-cst-request-target-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "absolute-form") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "absolute-form"))))
Theorem:
(defthm http-cst-request-target-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "authority-form") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "authority-form"))))
Theorem:
(defthm http-cst-request-target-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "asterisk-form") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "asterisk-form"))))
Theorem:
(defthm http-cst-start-line-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "request-line") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "request-line"))))
Theorem:
(defthm http-cst-start-line-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "status-line") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "status-line"))))
Theorem:
(defthm http-cst-status-code-conc-matching (implies (http-cst-list-list-conc-matchp cstss "3digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "3digit"))))
Theorem:
(defthm http-cst-t-codings-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "\"trailers\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"trailers\""))))
Theorem:
(defthm http-cst-t-codings-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "( transfer-coding [ t-ranking ] )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "( transfer-coding [ t-ranking ] )"))))
Theorem:
(defthm http-cst-tchar-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "\"!\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"!\""))))
Theorem:
(defthm http-cst-tchar-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "\"#\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"#\""))))
Theorem:
(defthm http-cst-tchar-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"$\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"$\""))))
Theorem:
(defthm http-cst-tchar-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\"%\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"%\""))))
Theorem:
(defthm http-cst-tchar-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "\"&\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"&\""))))
Theorem:
(defthm http-cst-tchar-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "\"'\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"'\""))))
Theorem:
(defthm http-cst-tchar-conc7-matching (implies (http-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm http-cst-tchar-conc8-matching (implies (http-cst-list-list-conc-matchp cstss "\"+\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"+\""))))
Theorem:
(defthm http-cst-tchar-conc9-matching (implies (http-cst-list-list-conc-matchp cstss "\"-\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"-\""))))
Theorem:
(defthm http-cst-tchar-conc10-matching (implies (http-cst-list-list-conc-matchp cstss "\".\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\".\""))))
Theorem:
(defthm http-cst-tchar-conc11-matching (implies (http-cst-list-list-conc-matchp cstss "\"^\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"^\""))))
Theorem:
(defthm http-cst-tchar-conc12-matching (implies (http-cst-list-list-conc-matchp cstss "\"_\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"_\""))))
Theorem:
(defthm http-cst-tchar-conc13-matching (implies (http-cst-list-list-conc-matchp cstss "\"`\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"`\""))))
Theorem:
(defthm http-cst-tchar-conc14-matching (implies (http-cst-list-list-conc-matchp cstss "\"|\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"|\""))))
Theorem:
(defthm http-cst-tchar-conc15-matching (implies (http-cst-list-list-conc-matchp cstss "\"~\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"~\""))))
Theorem:
(defthm http-cst-tchar-conc16-matching (implies (http-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm http-cst-tchar-conc17-matching (implies (http-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm http-cst-token-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*tchar") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*tchar"))))
Theorem:
(defthm http-cst-trailer-part-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( header-field crlf )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( header-field crlf )"))))
Theorem:
(defthm http-cst-transfer-coding-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "\"chunked\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"chunked\""))))
Theorem:
(defthm http-cst-transfer-coding-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "\"compress\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"compress\""))))
Theorem:
(defthm http-cst-transfer-coding-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"deflate\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"deflate\""))))
Theorem:
(defthm http-cst-transfer-coding-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\"gzip\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"gzip\""))))
Theorem:
(defthm http-cst-transfer-coding-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "transfer-extension") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "transfer-extension"))))
Theorem:
(defthm http-cst-fragment-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( pchar / \"/\" / \"?\" )"))))
Theorem:
(defthm http-cst-hier-part-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "path-absolute") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-absolute"))))
Theorem:
(defthm http-cst-hier-part-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "path-rootless") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-rootless"))))
Theorem:
(defthm http-cst-hier-part-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "path-empty") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-empty"))))
Theorem:
(defthm http-cst-path-abempty-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( \"/\" segment )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( \"/\" segment )"))))
Theorem:
(defthm http-cst-path-empty-conc-matching (implies (http-cst-list-list-conc-matchp cstss "0<pchar>") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "0<pchar>"))))
Theorem:
(defthm http-cst-pchar-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "unreserved") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "unreserved"))))
Theorem:
(defthm http-cst-pchar-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "pct-encoded") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "pct-encoded"))))
Theorem:
(defthm http-cst-pchar-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "sub-delims") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "sub-delims"))))
Theorem:
(defthm http-cst-pchar-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\":\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\":\""))))
Theorem:
(defthm http-cst-pchar-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "\"@\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"@\""))))
Theorem:
(defthm http-cst-port-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*digit"))))
Theorem:
(defthm http-cst-query-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( pchar / \"/\" / \"?\" )"))))
Theorem:
(defthm http-cst-relative-part-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "path-absolute") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-absolute"))))
Theorem:
(defthm http-cst-relative-part-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "path-noscheme") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-noscheme"))))
Theorem:
(defthm http-cst-relative-part-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "path-empty") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "path-empty"))))
Theorem:
(defthm http-cst-segment-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*pchar") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*pchar"))))
Theorem:
(defthm http-cst-segment-nz-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*pchar") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*pchar"))))
Theorem:
(defthm http-cst-segment-nz-nc-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*( unreserved / pct-encoded / sub-delims / \"@\" )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*( unreserved / pct-encoded / sub-delims / \"@\" )"))))
Theorem:
(defthm http-cst-sub-delims-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "\"!\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"!\""))))
Theorem:
(defthm http-cst-sub-delims-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "\"$\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"$\""))))
Theorem:
(defthm http-cst-sub-delims-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"&\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"&\""))))
Theorem:
(defthm http-cst-sub-delims-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\"'\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"'\""))))
Theorem:
(defthm http-cst-sub-delims-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "\"(\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"(\""))))
Theorem:
(defthm http-cst-sub-delims-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "\")\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\")\""))))
Theorem:
(defthm http-cst-sub-delims-conc7-matching (implies (http-cst-list-list-conc-matchp cstss "\"*\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"*\""))))
Theorem:
(defthm http-cst-sub-delims-conc8-matching (implies (http-cst-list-list-conc-matchp cstss "\"+\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"+\""))))
Theorem:
(defthm http-cst-sub-delims-conc9-matching (implies (http-cst-list-list-conc-matchp cstss "\",\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\",\""))))
Theorem:
(defthm http-cst-sub-delims-conc10-matching (implies (http-cst-list-list-conc-matchp cstss "\";\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\";\""))))
Theorem:
(defthm http-cst-sub-delims-conc11-matching (implies (http-cst-list-list-conc-matchp cstss "\"=\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"=\""))))
Theorem:
(defthm http-cst-unreserved-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "alpha") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "alpha"))))
Theorem:
(defthm http-cst-unreserved-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm http-cst-unreserved-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"-\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"-\""))))
Theorem:
(defthm http-cst-unreserved-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\".\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\".\""))))
Theorem:
(defthm http-cst-unreserved-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "\"_\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"_\""))))
Theorem:
(defthm http-cst-unreserved-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "\"~\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"~\""))))
Theorem:
(defthm http-cst-uri-host-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "ip-literal") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "ip-literal"))))
Theorem:
(defthm http-cst-uri-host-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "ipv4address") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "ipv4address"))))
Theorem:
(defthm http-cst-uri-host-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "reg-name") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "reg-name"))))
Theorem:
(defthm http-cst-dec-octet-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm http-cst-h16-conc-matching (implies (http-cst-list-list-conc-matchp cstss "1*4hexdig") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "1*4hexdig"))))
Theorem:
(defthm http-cst-ls32-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "( h16 \":\" h16 )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "( h16 \":\" h16 )"))))
Theorem:
(defthm http-cst-ls32-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "ipv4address") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "ipv4address"))))
Theorem:
(defthm http-cst-reg-name-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( unreserved / pct-encoded / sub-delims )"))))
Theorem:
(defthm http-cst-userinfo-conc-matching (implies (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims / \":\" )") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "*( unreserved / pct-encoded / sub-delims / \":\" )"))))
Theorem:
(defthm http-cst-alpha-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "%x41-5A") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x41-5A"))))
Theorem:
(defthm http-cst-alpha-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "%x61-7A") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x61-7A"))))
Theorem:
(defthm http-cst-cr-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%xD") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%xD"))))
Theorem:
(defthm http-cst-digit-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x30-39") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x30-39"))))
Theorem:
(defthm http-cst-dquote-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x22") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x22"))))
Theorem:
(defthm http-cst-hexdig-conc1-matching (implies (http-cst-list-list-conc-matchp cstss "digit") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "digit"))))
Theorem:
(defthm http-cst-hexdig-conc2-matching (implies (http-cst-list-list-conc-matchp cstss "\"A\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"A\""))))
Theorem:
(defthm http-cst-hexdig-conc3-matching (implies (http-cst-list-list-conc-matchp cstss "\"B\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"B\""))))
Theorem:
(defthm http-cst-hexdig-conc4-matching (implies (http-cst-list-list-conc-matchp cstss "\"C\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"C\""))))
Theorem:
(defthm http-cst-hexdig-conc5-matching (implies (http-cst-list-list-conc-matchp cstss "\"D\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"D\""))))
Theorem:
(defthm http-cst-hexdig-conc6-matching (implies (http-cst-list-list-conc-matchp cstss "\"E\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"E\""))))
Theorem:
(defthm http-cst-hexdig-conc7-matching (implies (http-cst-list-list-conc-matchp cstss "\"F\"") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "\"F\""))))
Theorem:
(defthm http-cst-htab-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x9") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x9"))))
Theorem:
(defthm http-cst-lf-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%xA") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%xA"))))
Theorem:
(defthm http-cst-octet-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x0-FF") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x0-FF"))))
Theorem:
(defthm http-cst-sp-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x20") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x20"))))
Theorem:
(defthm http-cst-vchar-conc-matching (implies (http-cst-list-list-conc-matchp cstss "%x21-7E") (and (equal (len cstss) 1) (http-cst-list-rep-matchp (nth 0 cstss) "%x21-7E"))))
Theorem:
(defthm http-cst-bws-conc-rep-matching (implies (http-cst-list-rep-matchp csts "ows") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "ows"))))
Theorem:
(defthm http-cst-http-name-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x48.54.54.50") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x48.54.54.50"))))
Theorem:
(defthm http-cst-te-conc-rep-matching (implies (http-cst-list-rep-matchp csts "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))))
Theorem:
(defthm http-cst-absolute-form-conc-rep-matching (implies (http-cst-list-rep-matchp csts "absolute-uri") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "absolute-uri"))))
Theorem:
(defthm http-cst-asterisk-form-conc-rep-matching (implies (http-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm http-cst-authority-form-conc-rep-matching (implies (http-cst-list-rep-matchp csts "authority") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "authority"))))
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "quoted-string") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "quoted-string"))))
Theorem:
(defthm http-cst-connection-option-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-ctext-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "htab") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "htab"))))
Theorem:
(defthm http-cst-ctext-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "sp") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "sp"))))
Theorem:
(defthm http-cst-ctext-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "%x21-27") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x21-27"))))
Theorem:
(defthm http-cst-ctext-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "%x2A-5B") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x2A-5B"))))
Theorem:
(defthm http-cst-ctext-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "%x5D-7E") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x5D-7E"))))
Theorem:
(defthm http-cst-ctext-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "obs-text") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "obs-text"))))
Theorem:
(defthm http-cst-field-name-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-field-vchar-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "vchar") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "vchar"))))
Theorem:
(defthm http-cst-field-vchar-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "obs-text") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "obs-text"))))
Theorem:
(defthm http-cst-method-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-obs-text-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x80-FF") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x80-FF"))))
Theorem:
(defthm http-cst-protocol-name-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-protocol-version-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-pseudonym-conc-rep-matching (implies (http-cst-list-rep-matchp csts "token") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "token"))))
Theorem:
(defthm http-cst-qdtext-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "htab") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "htab"))))
Theorem:
(defthm http-cst-qdtext-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "sp") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "sp"))))
Theorem:
(defthm http-cst-qdtext-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"!\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"!\""))))
Theorem:
(defthm http-cst-qdtext-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "%x23-5B") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x23-5B"))))
Theorem:
(defthm http-cst-qdtext-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "%x5D-7E") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x5D-7E"))))
Theorem:
(defthm http-cst-qdtext-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "obs-text") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "obs-text"))))
Theorem:
(defthm http-cst-rank-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "( \"0\" [ \".\" *3digit ] )") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "( \"0\" [ \".\" *3digit ] )"))))
Theorem:
(defthm http-cst-rank-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "( \"1\" [ \".\" *3\"0\" ] )") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "( \"1\" [ \".\" *3\"0\" ] )"))))
Theorem:
(defthm http-cst-received-by-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "( uri-host [ \":\" port ] )") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "( uri-host [ \":\" port ] )"))))
Theorem:
(defthm http-cst-received-by-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "pseudonym") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "pseudonym"))))
Theorem:
(defthm http-cst-request-target-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "origin-form") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "origin-form"))))
Theorem:
(defthm http-cst-request-target-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "absolute-form") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "absolute-form"))))
Theorem:
(defthm http-cst-request-target-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "authority-form") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "authority-form"))))
Theorem:
(defthm http-cst-request-target-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "asterisk-form") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "asterisk-form"))))
Theorem:
(defthm http-cst-start-line-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "request-line") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "request-line"))))
Theorem:
(defthm http-cst-start-line-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "status-line") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "status-line"))))
Theorem:
(defthm http-cst-t-codings-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "\"trailers\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"trailers\""))))
Theorem:
(defthm http-cst-t-codings-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "( transfer-coding [ t-ranking ] )") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "( transfer-coding [ t-ranking ] )"))))
Theorem:
(defthm http-cst-tchar-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "\"!\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"!\""))))
Theorem:
(defthm http-cst-tchar-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "\"#\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"#\""))))
Theorem:
(defthm http-cst-tchar-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"$\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"$\""))))
Theorem:
(defthm http-cst-tchar-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\"%\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"%\""))))
Theorem:
(defthm http-cst-tchar-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "\"&\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"&\""))))
Theorem:
(defthm http-cst-tchar-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "\"'\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"'\""))))
Theorem:
(defthm http-cst-tchar-conc7-rep-matching (implies (http-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm http-cst-tchar-conc8-rep-matching (implies (http-cst-list-rep-matchp csts "\"+\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"+\""))))
Theorem:
(defthm http-cst-tchar-conc9-rep-matching (implies (http-cst-list-rep-matchp csts "\"-\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"-\""))))
Theorem:
(defthm http-cst-tchar-conc10-rep-matching (implies (http-cst-list-rep-matchp csts "\".\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\".\""))))
Theorem:
(defthm http-cst-tchar-conc11-rep-matching (implies (http-cst-list-rep-matchp csts "\"^\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"^\""))))
Theorem:
(defthm http-cst-tchar-conc12-rep-matching (implies (http-cst-list-rep-matchp csts "\"_\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"_\""))))
Theorem:
(defthm http-cst-tchar-conc13-rep-matching (implies (http-cst-list-rep-matchp csts "\"`\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"`\""))))
Theorem:
(defthm http-cst-tchar-conc14-rep-matching (implies (http-cst-list-rep-matchp csts "\"|\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"|\""))))
Theorem:
(defthm http-cst-tchar-conc15-rep-matching (implies (http-cst-list-rep-matchp csts "\"~\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"~\""))))
Theorem:
(defthm http-cst-tchar-conc16-rep-matching (implies (http-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm http-cst-tchar-conc17-rep-matching (implies (http-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm http-cst-transfer-coding-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "\"chunked\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"chunked\""))))
Theorem:
(defthm http-cst-transfer-coding-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "\"compress\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"compress\""))))
Theorem:
(defthm http-cst-transfer-coding-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"deflate\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"deflate\""))))
Theorem:
(defthm http-cst-transfer-coding-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\"gzip\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"gzip\""))))
Theorem:
(defthm http-cst-transfer-coding-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "transfer-extension") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "transfer-extension"))))
Theorem:
(defthm http-cst-hier-part-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "path-absolute") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-absolute"))))
Theorem:
(defthm http-cst-hier-part-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "path-rootless") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-rootless"))))
Theorem:
(defthm http-cst-hier-part-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "path-empty") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-empty"))))
Theorem:
(defthm http-cst-pchar-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "unreserved") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "unreserved"))))
Theorem:
(defthm http-cst-pchar-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "pct-encoded") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "pct-encoded"))))
Theorem:
(defthm http-cst-pchar-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "sub-delims") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "sub-delims"))))
Theorem:
(defthm http-cst-pchar-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\":\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\":\""))))
Theorem:
(defthm http-cst-pchar-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "\"@\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"@\""))))
Theorem:
(defthm http-cst-relative-part-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "path-absolute") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-absolute"))))
Theorem:
(defthm http-cst-relative-part-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "path-noscheme") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-noscheme"))))
Theorem:
(defthm http-cst-relative-part-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "path-empty") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "path-empty"))))
Theorem:
(defthm http-cst-sub-delims-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "\"!\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"!\""))))
Theorem:
(defthm http-cst-sub-delims-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "\"$\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"$\""))))
Theorem:
(defthm http-cst-sub-delims-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"&\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"&\""))))
Theorem:
(defthm http-cst-sub-delims-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\"'\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"'\""))))
Theorem:
(defthm http-cst-sub-delims-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "\"(\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"(\""))))
Theorem:
(defthm http-cst-sub-delims-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "\")\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\")\""))))
Theorem:
(defthm http-cst-sub-delims-conc7-rep-matching (implies (http-cst-list-rep-matchp csts "\"*\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"*\""))))
Theorem:
(defthm http-cst-sub-delims-conc8-rep-matching (implies (http-cst-list-rep-matchp csts "\"+\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"+\""))))
Theorem:
(defthm http-cst-sub-delims-conc9-rep-matching (implies (http-cst-list-rep-matchp csts "\",\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\",\""))))
Theorem:
(defthm http-cst-sub-delims-conc10-rep-matching (implies (http-cst-list-rep-matchp csts "\";\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\";\""))))
Theorem:
(defthm http-cst-sub-delims-conc11-rep-matching (implies (http-cst-list-rep-matchp csts "\"=\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"=\""))))
Theorem:
(defthm http-cst-unreserved-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "alpha") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "alpha"))))
Theorem:
(defthm http-cst-unreserved-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm http-cst-unreserved-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"-\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"-\""))))
Theorem:
(defthm http-cst-unreserved-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\".\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\".\""))))
Theorem:
(defthm http-cst-unreserved-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "\"_\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"_\""))))
Theorem:
(defthm http-cst-unreserved-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "\"~\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"~\""))))
Theorem:
(defthm http-cst-uri-host-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "ip-literal") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "ip-literal"))))
Theorem:
(defthm http-cst-uri-host-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "ipv4address") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "ipv4address"))))
Theorem:
(defthm http-cst-uri-host-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "reg-name") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "reg-name"))))
Theorem:
(defthm http-cst-dec-octet-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm http-cst-ls32-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "( h16 \":\" h16 )") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "( h16 \":\" h16 )"))))
Theorem:
(defthm http-cst-ls32-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "ipv4address") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "ipv4address"))))
Theorem:
(defthm http-cst-alpha-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "%x41-5A") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x41-5A"))))
Theorem:
(defthm http-cst-alpha-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "%x61-7A") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x61-7A"))))
Theorem:
(defthm http-cst-cr-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%xD") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%xD"))))
Theorem:
(defthm http-cst-digit-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x30-39") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x30-39"))))
Theorem:
(defthm http-cst-dquote-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x22") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x22"))))
Theorem:
(defthm http-cst-hexdig-conc1-rep-matching (implies (http-cst-list-rep-matchp csts "digit") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "digit"))))
Theorem:
(defthm http-cst-hexdig-conc2-rep-matching (implies (http-cst-list-rep-matchp csts "\"A\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"A\""))))
Theorem:
(defthm http-cst-hexdig-conc3-rep-matching (implies (http-cst-list-rep-matchp csts "\"B\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"B\""))))
Theorem:
(defthm http-cst-hexdig-conc4-rep-matching (implies (http-cst-list-rep-matchp csts "\"C\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"C\""))))
Theorem:
(defthm http-cst-hexdig-conc5-rep-matching (implies (http-cst-list-rep-matchp csts "\"D\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"D\""))))
Theorem:
(defthm http-cst-hexdig-conc6-rep-matching (implies (http-cst-list-rep-matchp csts "\"E\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"E\""))))
Theorem:
(defthm http-cst-hexdig-conc7-rep-matching (implies (http-cst-list-rep-matchp csts "\"F\"") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "\"F\""))))
Theorem:
(defthm http-cst-htab-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x9") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x9"))))
Theorem:
(defthm http-cst-lf-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%xA") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%xA"))))
Theorem:
(defthm http-cst-octet-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x0-FF") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x0-FF"))))
Theorem:
(defthm http-cst-sp-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x20") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x20"))))
Theorem:
(defthm http-cst-vchar-conc-rep-matching (implies (http-cst-list-rep-matchp csts "%x21-7E") (and (equal (len csts) 1) (http-cst-matchp (nth 0 csts) "%x21-7E"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc-equivs (implies (http-cst-matchp cst "chunk-ext-val") (and (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "token") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "token"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string"))))))
Theorem:
(defthm http-cst-field-vchar-conc-equivs (implies (http-cst-matchp cst "field-vchar") (and (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "vchar") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "vchar"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-text") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-text"))))))
Theorem:
(defthm http-cst-request-target-conc-equivs (implies (http-cst-matchp cst "request-target") (and (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "origin-form") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "origin-form"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "absolute-form") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "absolute-form"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "authority-form") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "authority-form"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "asterisk-form") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "asterisk-form"))))))
Theorem:
(defthm http-cst-start-line-conc-equivs (implies (http-cst-matchp cst "start-line") (and (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "request-line") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "request-line"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "status-line") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "status-line"))))))
Theorem:
(defthm http-cst-uri-host-conc-equivs (implies (http-cst-matchp cst "uri-host") (and (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ip-literal") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ip-literal"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv4address") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv4address"))) (iff (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reg-name") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reg-name"))))))
Function:
(defun http-cst-chunk-ext-val-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-ext-val"))) (let ((__function__ 'http-cst-chunk-ext-val-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "token")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "quoted-string")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-http-cst-chunk-ext-val-conc? (b* ((number (http-cst-chunk-ext-val-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc?-possibilities (b* ((number (http-cst-chunk-ext-val-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((http-cst-chunk-ext-val-conc? cst)))))
Theorem:
(defthm http-cst-chunk-ext-val-conc?-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc? (tree-fix cst)) (http-cst-chunk-ext-val-conc? cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc? cst) (http-cst-chunk-ext-val-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-chunk-ext-val-conc?-1-iff-match-conc (implies (http-cst-matchp cst "chunk-ext-val") (iff (equal (http-cst-chunk-ext-val-conc? cst) 1) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "token"))))
Theorem:
(defthm http-cst-chunk-ext-val-conc?-2-iff-match-conc (implies (http-cst-matchp cst "chunk-ext-val") (iff (equal (http-cst-chunk-ext-val-conc? cst) 2) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "quoted-string"))))
Function:
(defun http-cst-field-vchar-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-vchar"))) (let ((__function__ 'http-cst-field-vchar-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "vchar")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "obs-text")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-http-cst-field-vchar-conc? (b* ((number (http-cst-field-vchar-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc?-possibilities (b* ((number (http-cst-field-vchar-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((http-cst-field-vchar-conc? cst)))))
Theorem:
(defthm http-cst-field-vchar-conc?-of-tree-fix-cst (equal (http-cst-field-vchar-conc? (tree-fix cst)) (http-cst-field-vchar-conc? cst)))
Theorem:
(defthm http-cst-field-vchar-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc? cst) (http-cst-field-vchar-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-field-vchar-conc?-1-iff-match-conc (implies (http-cst-matchp cst "field-vchar") (iff (equal (http-cst-field-vchar-conc? cst) 1) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "vchar"))))
Theorem:
(defthm http-cst-field-vchar-conc?-2-iff-match-conc (implies (http-cst-matchp cst "field-vchar") (iff (equal (http-cst-field-vchar-conc? cst) 2) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "obs-text"))))
Function:
(defun http-cst-request-target-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "request-target"))) (let ((__function__ 'http-cst-request-target-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "origin-form")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "absolute-form")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "authority-form")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "asterisk-form")) 4) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-http-cst-request-target-conc? (b* ((number (http-cst-request-target-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc?-possibilities (b* ((number (http-cst-request-target-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4))) :rule-classes ((:forward-chaining :trigger-terms ((http-cst-request-target-conc? cst)))))
Theorem:
(defthm http-cst-request-target-conc?-of-tree-fix-cst (equal (http-cst-request-target-conc? (tree-fix cst)) (http-cst-request-target-conc? cst)))
Theorem:
(defthm http-cst-request-target-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc? cst) (http-cst-request-target-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-request-target-conc?-1-iff-match-conc (implies (http-cst-matchp cst "request-target") (iff (equal (http-cst-request-target-conc? cst) 1) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "origin-form"))))
Theorem:
(defthm http-cst-request-target-conc?-2-iff-match-conc (implies (http-cst-matchp cst "request-target") (iff (equal (http-cst-request-target-conc? cst) 2) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "absolute-form"))))
Theorem:
(defthm http-cst-request-target-conc?-3-iff-match-conc (implies (http-cst-matchp cst "request-target") (iff (equal (http-cst-request-target-conc? cst) 3) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "authority-form"))))
Theorem:
(defthm http-cst-request-target-conc?-4-iff-match-conc (implies (http-cst-matchp cst "request-target") (iff (equal (http-cst-request-target-conc? cst) 4) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "asterisk-form"))))
Function:
(defun http-cst-start-line-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "start-line"))) (let ((__function__ 'http-cst-start-line-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "request-line")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "status-line")) 2) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-http-cst-start-line-conc? (b* ((number (http-cst-start-line-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc?-possibilities (b* ((number (http-cst-start-line-conc? cst))) (or (equal number 1) (equal number 2))) :rule-classes ((:forward-chaining :trigger-terms ((http-cst-start-line-conc? cst)))))
Theorem:
(defthm http-cst-start-line-conc?-of-tree-fix-cst (equal (http-cst-start-line-conc? (tree-fix cst)) (http-cst-start-line-conc? cst)))
Theorem:
(defthm http-cst-start-line-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc? cst) (http-cst-start-line-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-start-line-conc?-1-iff-match-conc (implies (http-cst-matchp cst "start-line") (iff (equal (http-cst-start-line-conc? cst) 1) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "request-line"))))
Theorem:
(defthm http-cst-start-line-conc?-2-iff-match-conc (implies (http-cst-matchp cst "start-line") (iff (equal (http-cst-start-line-conc? cst) 2) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "status-line"))))
Function:
(defun http-cst-uri-host-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "uri-host"))) (let ((__function__ 'http-cst-uri-host-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ip-literal")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "ipv4address")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reg-name")) 3) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-http-cst-uri-host-conc? (b* ((number (http-cst-uri-host-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc?-possibilities (b* ((number (http-cst-uri-host-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3))) :rule-classes ((:forward-chaining :trigger-terms ((http-cst-uri-host-conc? cst)))))
Theorem:
(defthm http-cst-uri-host-conc?-of-tree-fix-cst (equal (http-cst-uri-host-conc? (tree-fix cst)) (http-cst-uri-host-conc? cst)))
Theorem:
(defthm http-cst-uri-host-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc? cst) (http-cst-uri-host-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm http-cst-uri-host-conc?-1-iff-match-conc (implies (http-cst-matchp cst "uri-host") (iff (equal (http-cst-uri-host-conc? cst) 1) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ip-literal"))))
Theorem:
(defthm http-cst-uri-host-conc?-2-iff-match-conc (implies (http-cst-matchp cst "uri-host") (iff (equal (http-cst-uri-host-conc? cst) 2) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "ipv4address"))))
Theorem:
(defthm http-cst-uri-host-conc?-3-iff-match-conc (implies (http-cst-matchp cst "uri-host") (iff (equal (http-cst-uri-host-conc? cst) 3) (http-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reg-name"))))
Function:
(defun http-cst-bws-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "bws"))) (let ((__function__ 'http-cst-bws-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-bws-conc (b* ((cstss (http-cst-bws-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-match (implies (http-cst-matchp cst "bws") (b* ((cstss (http-cst-bws-conc cst))) (http-cst-list-list-conc-matchp cstss "ows"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-of-tree-fix-cst (equal (http-cst-bws-conc (tree-fix cst)) (http-cst-bws-conc cst)))
Theorem:
(defthm http-cst-bws-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-bws-conc cst) (http-cst-bws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-connection-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "connection"))) (let ((__function__ 'http-cst-connection-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-connection-conc (b* ((cstss (http-cst-connection-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-conc-match (implies (http-cst-matchp cst "connection") (b* ((cstss (http-cst-connection-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) connection-option *( ows \",\" [ ows connection-option ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-conc-of-tree-fix-cst (equal (http-cst-connection-conc (tree-fix cst)) (http-cst-connection-conc cst)))
Theorem:
(defthm http-cst-connection-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-connection-conc cst) (http-cst-connection-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-content-length-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "content-length"))) (let ((__function__ 'http-cst-content-length-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-content-length-conc (b* ((cstss (http-cst-content-length-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-content-length-conc-match (implies (http-cst-matchp cst "content-length") (b* ((cstss (http-cst-content-length-conc cst))) (http-cst-list-list-conc-matchp cstss "1*digit"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-content-length-conc-of-tree-fix-cst (equal (http-cst-content-length-conc (tree-fix cst)) (http-cst-content-length-conc cst)))
Theorem:
(defthm http-cst-content-length-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-content-length-conc cst) (http-cst-content-length-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-message-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-message"))) (let ((__function__ 'http-cst-http-message-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-http-message-conc (b* ((cstss (http-cst-http-message-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-message-conc-match (implies (http-cst-matchp cst "http-message") (b* ((cstss (http-cst-http-message-conc cst))) (http-cst-list-list-conc-matchp cstss "start-line *( header-field crlf ) crlf [ message-body ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-message-conc-of-tree-fix-cst (equal (http-cst-http-message-conc (tree-fix cst)) (http-cst-http-message-conc cst)))
Theorem:
(defthm http-cst-http-message-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-message-conc cst) (http-cst-http-message-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-name"))) (let ((__function__ 'http-cst-http-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-http-name-conc (b* ((cstss (http-cst-http-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-match (implies (http-cst-matchp cst "http-name") (b* ((cstss (http-cst-http-name-conc cst))) (http-cst-list-list-conc-matchp cstss "%x48.54.54.50"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-of-tree-fix-cst (equal (http-cst-http-name-conc (tree-fix cst)) (http-cst-http-name-conc cst)))
Theorem:
(defthm http-cst-http-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-name-conc cst) (http-cst-http-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-version-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-version"))) (let ((__function__ 'http-cst-http-version-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-http-version-conc (b* ((cstss (http-cst-http-version-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-version-conc-match (implies (http-cst-matchp cst "http-version") (b* ((cstss (http-cst-http-version-conc cst))) (http-cst-list-list-conc-matchp cstss "http-name \"/\" digit \".\" digit"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-version-conc-of-tree-fix-cst (equal (http-cst-http-version-conc (tree-fix cst)) (http-cst-http-version-conc cst)))
Theorem:
(defthm http-cst-http-version-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-version-conc cst) (http-cst-http-version-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-host-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "host"))) (let ((__function__ 'http-cst-host-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-host-conc (b* ((cstss (http-cst-host-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-host-conc-match (implies (http-cst-matchp cst "host") (b* ((cstss (http-cst-host-conc cst))) (http-cst-list-list-conc-matchp cstss "uri-host [ \":\" port ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-host-conc-of-tree-fix-cst (equal (http-cst-host-conc (tree-fix cst)) (http-cst-host-conc cst)))
Theorem:
(defthm http-cst-host-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-host-conc cst) (http-cst-host-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-ows-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "ows"))) (let ((__function__ 'http-cst-ows-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-ows-conc (b* ((cstss (http-cst-ows-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ows-conc-match (implies (http-cst-matchp cst "ows") (b* ((cstss (http-cst-ows-conc cst))) (http-cst-list-list-conc-matchp cstss "*( sp / htab )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ows-conc-of-tree-fix-cst (equal (http-cst-ows-conc (tree-fix cst)) (http-cst-ows-conc cst)))
Theorem:
(defthm http-cst-ows-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-ows-conc cst) (http-cst-ows-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-rws-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "rws"))) (let ((__function__ 'http-cst-rws-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-rws-conc (b* ((cstss (http-cst-rws-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-rws-conc-match (implies (http-cst-matchp cst "rws") (b* ((cstss (http-cst-rws-conc cst))) (http-cst-list-list-conc-matchp cstss "1*( sp / htab )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-rws-conc-of-tree-fix-cst (equal (http-cst-rws-conc (tree-fix cst)) (http-cst-rws-conc cst)))
Theorem:
(defthm http-cst-rws-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-rws-conc cst) (http-cst-rws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-te-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "te"))) (let ((__function__ 'http-cst-te-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-te-conc (b* ((cstss (http-cst-te-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-match (implies (http-cst-matchp cst "te") (b* ((cstss (http-cst-te-conc cst))) (http-cst-list-list-conc-matchp cstss "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-of-tree-fix-cst (equal (http-cst-te-conc (tree-fix cst)) (http-cst-te-conc cst)))
Theorem:
(defthm http-cst-te-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-te-conc cst) (http-cst-te-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-trailer-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "trailer"))) (let ((__function__ 'http-cst-trailer-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-trailer-conc (b* ((cstss (http-cst-trailer-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-trailer-conc-match (implies (http-cst-matchp cst "trailer") (b* ((cstss (http-cst-trailer-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) field-name *( ows \",\" [ ows field-name ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-trailer-conc-of-tree-fix-cst (equal (http-cst-trailer-conc (tree-fix cst)) (http-cst-trailer-conc cst)))
Theorem:
(defthm http-cst-trailer-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-trailer-conc cst) (http-cst-trailer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-transfer-encoding-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "transfer-encoding"))) (let ((__function__ 'http-cst-transfer-encoding-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-transfer-encoding-conc (b* ((cstss (http-cst-transfer-encoding-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-encoding-conc-match (implies (http-cst-matchp cst "transfer-encoding") (b* ((cstss (http-cst-transfer-encoding-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) transfer-coding *( ows \",\" [ ows transfer-coding ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-encoding-conc-of-tree-fix-cst (equal (http-cst-transfer-encoding-conc (tree-fix cst)) (http-cst-transfer-encoding-conc cst)))
Theorem:
(defthm http-cst-transfer-encoding-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-transfer-encoding-conc cst) (http-cst-transfer-encoding-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-upgrade-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "upgrade"))) (let ((__function__ 'http-cst-upgrade-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-upgrade-conc (b* ((cstss (http-cst-upgrade-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-upgrade-conc-match (implies (http-cst-matchp cst "upgrade") (b* ((cstss (http-cst-upgrade-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) protocol *( ows \",\" [ ows protocol ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-upgrade-conc-of-tree-fix-cst (equal (http-cst-upgrade-conc (tree-fix cst)) (http-cst-upgrade-conc cst)))
Theorem:
(defthm http-cst-upgrade-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-upgrade-conc cst) (http-cst-upgrade-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-via-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "via"))) (let ((__function__ 'http-cst-via-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-via-conc (b* ((cstss (http-cst-via-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-via-conc-match (implies (http-cst-matchp cst "via") (b* ((cstss (http-cst-via-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \",\" ows ) ( received-protocol rws received-by [ rws comment ] ) *( ows \",\" [ ows ( received-protocol rws received-by [ rws comment ] ) ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-via-conc-of-tree-fix-cst (equal (http-cst-via-conc (tree-fix cst)) (http-cst-via-conc cst)))
Theorem:
(defthm http-cst-via-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-via-conc cst) (http-cst-via-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-absolute-form-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "absolute-form"))) (let ((__function__ 'http-cst-absolute-form-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-absolute-form-conc (b* ((cstss (http-cst-absolute-form-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-match (implies (http-cst-matchp cst "absolute-form") (b* ((cstss (http-cst-absolute-form-conc cst))) (http-cst-list-list-conc-matchp cstss "absolute-uri"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-of-tree-fix-cst (equal (http-cst-absolute-form-conc (tree-fix cst)) (http-cst-absolute-form-conc cst)))
Theorem:
(defthm http-cst-absolute-form-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-absolute-form-conc cst) (http-cst-absolute-form-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-absolute-path-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "absolute-path"))) (let ((__function__ 'http-cst-absolute-path-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-absolute-path-conc (b* ((cstss (http-cst-absolute-path-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-path-conc-match (implies (http-cst-matchp cst "absolute-path") (b* ((cstss (http-cst-absolute-path-conc cst))) (http-cst-list-list-conc-matchp cstss "1*( \"/\" segment )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-path-conc-of-tree-fix-cst (equal (http-cst-absolute-path-conc (tree-fix cst)) (http-cst-absolute-path-conc cst)))
Theorem:
(defthm http-cst-absolute-path-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-absolute-path-conc cst) (http-cst-absolute-path-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-asterisk-form-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "asterisk-form"))) (let ((__function__ 'http-cst-asterisk-form-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-asterisk-form-conc (b* ((cstss (http-cst-asterisk-form-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-match (implies (http-cst-matchp cst "asterisk-form") (b* ((cstss (http-cst-asterisk-form-conc cst))) (http-cst-list-list-conc-matchp cstss "\"*\""))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-of-tree-fix-cst (equal (http-cst-asterisk-form-conc (tree-fix cst)) (http-cst-asterisk-form-conc cst)))
Theorem:
(defthm http-cst-asterisk-form-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-asterisk-form-conc cst) (http-cst-asterisk-form-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-authority-form-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "authority-form"))) (let ((__function__ 'http-cst-authority-form-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-authority-form-conc (b* ((cstss (http-cst-authority-form-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-match (implies (http-cst-matchp cst "authority-form") (b* ((cstss (http-cst-authority-form-conc cst))) (http-cst-list-list-conc-matchp cstss "authority"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-of-tree-fix-cst (equal (http-cst-authority-form-conc (tree-fix cst)) (http-cst-authority-form-conc cst)))
Theorem:
(defthm http-cst-authority-form-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-authority-form-conc cst) (http-cst-authority-form-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk"))) (let ((__function__ 'http-cst-chunk-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-conc (b* ((cstss (http-cst-chunk-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-conc-match (implies (http-cst-matchp cst "chunk") (b* ((cstss (http-cst-chunk-conc cst))) (http-cst-list-list-conc-matchp cstss "chunk-size [ chunk-ext ] crlf chunk-data crlf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-conc-of-tree-fix-cst (equal (http-cst-chunk-conc (tree-fix cst)) (http-cst-chunk-conc cst)))
Theorem:
(defthm http-cst-chunk-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-conc cst) (http-cst-chunk-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-data-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-data"))) (let ((__function__ 'http-cst-chunk-data-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-data-conc (b* ((cstss (http-cst-chunk-data-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-data-conc-match (implies (http-cst-matchp cst "chunk-data") (b* ((cstss (http-cst-chunk-data-conc cst))) (http-cst-list-list-conc-matchp cstss "1*octet"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-data-conc-of-tree-fix-cst (equal (http-cst-chunk-data-conc (tree-fix cst)) (http-cst-chunk-data-conc cst)))
Theorem:
(defthm http-cst-chunk-data-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-data-conc cst) (http-cst-chunk-data-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-ext"))) (let ((__function__ 'http-cst-chunk-ext-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-ext-conc (b* ((cstss (http-cst-chunk-ext-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-conc-match (implies (http-cst-matchp cst "chunk-ext") (b* ((cstss (http-cst-chunk-ext-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-conc-of-tree-fix-cst (equal (http-cst-chunk-ext-conc (tree-fix cst)) (http-cst-chunk-ext-conc cst)))
Theorem:
(defthm http-cst-chunk-ext-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-conc cst) (http-cst-chunk-ext-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-ext-name"))) (let ((__function__ 'http-cst-chunk-ext-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-ext-name-conc (b* ((cstss (http-cst-chunk-ext-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-match (implies (http-cst-matchp cst "chunk-ext-name") (b* ((cstss (http-cst-chunk-ext-name-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-of-tree-fix-cst (equal (http-cst-chunk-ext-name-conc (tree-fix cst)) (http-cst-chunk-ext-name-conc cst)))
Theorem:
(defthm http-cst-chunk-ext-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-name-conc cst) (http-cst-chunk-ext-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)))) (let ((__function__ 'http-cst-chunk-ext-val-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-ext-val-conc1 (b* ((cstss (http-cst-chunk-ext-val-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)) (b* ((cstss (http-cst-chunk-ext-val-conc1 cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc1 (tree-fix cst)) (http-cst-chunk-ext-val-conc1 cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc1 cst) (http-cst-chunk-ext-val-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)))) (let ((__function__ 'http-cst-chunk-ext-val-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-ext-val-conc2 (b* ((cstss (http-cst-chunk-ext-val-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)) (b* ((cstss (http-cst-chunk-ext-val-conc2 cst))) (http-cst-list-list-conc-matchp cstss "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc2 (tree-fix cst)) (http-cst-chunk-ext-val-conc2 cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc2 cst) (http-cst-chunk-ext-val-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-size-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-size"))) (let ((__function__ 'http-cst-chunk-size-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunk-size-conc (b* ((cstss (http-cst-chunk-size-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-size-conc-match (implies (http-cst-matchp cst "chunk-size") (b* ((cstss (http-cst-chunk-size-conc cst))) (http-cst-list-list-conc-matchp cstss "1*hexdig"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-size-conc-of-tree-fix-cst (equal (http-cst-chunk-size-conc (tree-fix cst)) (http-cst-chunk-size-conc cst)))
Theorem:
(defthm http-cst-chunk-size-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-size-conc cst) (http-cst-chunk-size-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunked-body-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunked-body"))) (let ((__function__ 'http-cst-chunked-body-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-chunked-body-conc (b* ((cstss (http-cst-chunked-body-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunked-body-conc-match (implies (http-cst-matchp cst "chunked-body") (b* ((cstss (http-cst-chunked-body-conc cst))) (http-cst-list-list-conc-matchp cstss "*chunk last-chunk trailer-part crlf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunked-body-conc-of-tree-fix-cst (equal (http-cst-chunked-body-conc (tree-fix cst)) (http-cst-chunked-body-conc cst)))
Theorem:
(defthm http-cst-chunked-body-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunked-body-conc cst) (http-cst-chunked-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-comment-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "comment"))) (let ((__function__ 'http-cst-comment-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-comment-conc (b* ((cstss (http-cst-comment-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-comment-conc-match (implies (http-cst-matchp cst "comment") (b* ((cstss (http-cst-comment-conc cst))) (http-cst-list-list-conc-matchp cstss "\"(\" *( ctext / quoted-pair / comment ) \")\""))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-comment-conc-of-tree-fix-cst (equal (http-cst-comment-conc (tree-fix cst)) (http-cst-comment-conc cst)))
Theorem:
(defthm http-cst-comment-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-comment-conc cst) (http-cst-comment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-connection-option-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "connection-option"))) (let ((__function__ 'http-cst-connection-option-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-connection-option-conc (b* ((cstss (http-cst-connection-option-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-match (implies (http-cst-matchp cst "connection-option") (b* ((cstss (http-cst-connection-option-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-of-tree-fix-cst (equal (http-cst-connection-option-conc (tree-fix cst)) (http-cst-connection-option-conc cst)))
Theorem:
(defthm http-cst-connection-option-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-connection-option-conc cst) (http-cst-connection-option-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-content-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-content"))) (let ((__function__ 'http-cst-field-content-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-field-content-conc (b* ((cstss (http-cst-field-content-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-content-conc-match (implies (http-cst-matchp cst "field-content") (b* ((cstss (http-cst-field-content-conc cst))) (http-cst-list-list-conc-matchp cstss "field-vchar [ 1*( sp / htab ) field-vchar ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-content-conc-of-tree-fix-cst (equal (http-cst-field-content-conc (tree-fix cst)) (http-cst-field-content-conc cst)))
Theorem:
(defthm http-cst-field-content-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-content-conc cst) (http-cst-field-content-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-name"))) (let ((__function__ 'http-cst-field-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-field-name-conc (b* ((cstss (http-cst-field-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-match (implies (http-cst-matchp cst "field-name") (b* ((cstss (http-cst-field-name-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-of-tree-fix-cst (equal (http-cst-field-name-conc (tree-fix cst)) (http-cst-field-name-conc cst)))
Theorem:
(defthm http-cst-field-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-name-conc cst) (http-cst-field-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-value-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-value"))) (let ((__function__ 'http-cst-field-value-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-field-value-conc (b* ((cstss (http-cst-field-value-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-value-conc-match (implies (http-cst-matchp cst "field-value") (b* ((cstss (http-cst-field-value-conc cst))) (http-cst-list-list-conc-matchp cstss "*( field-content / obs-fold )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-value-conc-of-tree-fix-cst (equal (http-cst-field-value-conc (tree-fix cst)) (http-cst-field-value-conc cst)))
Theorem:
(defthm http-cst-field-value-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-value-conc cst) (http-cst-field-value-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)))) (let ((__function__ 'http-cst-field-vchar-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-field-vchar-conc1 (b* ((cstss (http-cst-field-vchar-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)) (b* ((cstss (http-cst-field-vchar-conc1 cst))) (http-cst-list-list-conc-matchp cstss "vchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-of-tree-fix-cst (equal (http-cst-field-vchar-conc1 (tree-fix cst)) (http-cst-field-vchar-conc1 cst)))
Theorem:
(defthm http-cst-field-vchar-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc1 cst) (http-cst-field-vchar-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)))) (let ((__function__ 'http-cst-field-vchar-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-field-vchar-conc2 (b* ((cstss (http-cst-field-vchar-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)) (b* ((cstss (http-cst-field-vchar-conc2 cst))) (http-cst-list-list-conc-matchp cstss "obs-text"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-of-tree-fix-cst (equal (http-cst-field-vchar-conc2 (tree-fix cst)) (http-cst-field-vchar-conc2 cst)))
Theorem:
(defthm http-cst-field-vchar-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc2 cst) (http-cst-field-vchar-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-header-field-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "header-field"))) (let ((__function__ 'http-cst-header-field-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-header-field-conc (b* ((cstss (http-cst-header-field-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-header-field-conc-match (implies (http-cst-matchp cst "header-field") (b* ((cstss (http-cst-header-field-conc cst))) (http-cst-list-list-conc-matchp cstss "field-name \":\" ows field-value ows"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-header-field-conc-of-tree-fix-cst (equal (http-cst-header-field-conc (tree-fix cst)) (http-cst-header-field-conc cst)))
Theorem:
(defthm http-cst-header-field-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-header-field-conc cst) (http-cst-header-field-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-uri-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-uri"))) (let ((__function__ 'http-cst-http-uri-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-http-uri-conc (b* ((cstss (http-cst-http-uri-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-uri-conc-match (implies (http-cst-matchp cst "http-uri") (b* ((cstss (http-cst-http-uri-conc cst))) (http-cst-list-list-conc-matchp cstss "\"http://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-uri-conc-of-tree-fix-cst (equal (http-cst-http-uri-conc (tree-fix cst)) (http-cst-http-uri-conc cst)))
Theorem:
(defthm http-cst-http-uri-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-uri-conc cst) (http-cst-http-uri-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-https-uri-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "https-uri"))) (let ((__function__ 'http-cst-https-uri-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-https-uri-conc (b* ((cstss (http-cst-https-uri-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-https-uri-conc-match (implies (http-cst-matchp cst "https-uri") (b* ((cstss (http-cst-https-uri-conc cst))) (http-cst-list-list-conc-matchp cstss "\"https://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-https-uri-conc-of-tree-fix-cst (equal (http-cst-https-uri-conc (tree-fix cst)) (http-cst-https-uri-conc cst)))
Theorem:
(defthm http-cst-https-uri-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-https-uri-conc cst) (http-cst-https-uri-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-last-chunk-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "last-chunk"))) (let ((__function__ 'http-cst-last-chunk-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-last-chunk-conc (b* ((cstss (http-cst-last-chunk-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-last-chunk-conc-match (implies (http-cst-matchp cst "last-chunk") (b* ((cstss (http-cst-last-chunk-conc cst))) (http-cst-list-list-conc-matchp cstss "1*\"0\" [ chunk-ext ] crlf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-last-chunk-conc-of-tree-fix-cst (equal (http-cst-last-chunk-conc (tree-fix cst)) (http-cst-last-chunk-conc cst)))
Theorem:
(defthm http-cst-last-chunk-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-last-chunk-conc cst) (http-cst-last-chunk-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-message-body-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "message-body"))) (let ((__function__ 'http-cst-message-body-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-message-body-conc (b* ((cstss (http-cst-message-body-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-message-body-conc-match (implies (http-cst-matchp cst "message-body") (b* ((cstss (http-cst-message-body-conc cst))) (http-cst-list-list-conc-matchp cstss "*octet"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-message-body-conc-of-tree-fix-cst (equal (http-cst-message-body-conc (tree-fix cst)) (http-cst-message-body-conc cst)))
Theorem:
(defthm http-cst-message-body-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-message-body-conc cst) (http-cst-message-body-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-method-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "method"))) (let ((__function__ 'http-cst-method-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-method-conc (b* ((cstss (http-cst-method-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-match (implies (http-cst-matchp cst "method") (b* ((cstss (http-cst-method-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-of-tree-fix-cst (equal (http-cst-method-conc (tree-fix cst)) (http-cst-method-conc cst)))
Theorem:
(defthm http-cst-method-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-method-conc cst) (http-cst-method-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-obs-fold-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "obs-fold"))) (let ((__function__ 'http-cst-obs-fold-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-obs-fold-conc (b* ((cstss (http-cst-obs-fold-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-fold-conc-match (implies (http-cst-matchp cst "obs-fold") (b* ((cstss (http-cst-obs-fold-conc cst))) (http-cst-list-list-conc-matchp cstss "crlf 1*( sp / htab )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-fold-conc-of-tree-fix-cst (equal (http-cst-obs-fold-conc (tree-fix cst)) (http-cst-obs-fold-conc cst)))
Theorem:
(defthm http-cst-obs-fold-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-obs-fold-conc cst) (http-cst-obs-fold-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-obs-text-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "obs-text"))) (let ((__function__ 'http-cst-obs-text-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-obs-text-conc (b* ((cstss (http-cst-obs-text-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-match (implies (http-cst-matchp cst "obs-text") (b* ((cstss (http-cst-obs-text-conc cst))) (http-cst-list-list-conc-matchp cstss "%x80-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-of-tree-fix-cst (equal (http-cst-obs-text-conc (tree-fix cst)) (http-cst-obs-text-conc cst)))
Theorem:
(defthm http-cst-obs-text-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-obs-text-conc cst) (http-cst-obs-text-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-origin-form-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "origin-form"))) (let ((__function__ 'http-cst-origin-form-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-origin-form-conc (b* ((cstss (http-cst-origin-form-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-origin-form-conc-match (implies (http-cst-matchp cst "origin-form") (b* ((cstss (http-cst-origin-form-conc cst))) (http-cst-list-list-conc-matchp cstss "absolute-path [ \"?\" query ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-origin-form-conc-of-tree-fix-cst (equal (http-cst-origin-form-conc (tree-fix cst)) (http-cst-origin-form-conc cst)))
Theorem:
(defthm http-cst-origin-form-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-origin-form-conc cst) (http-cst-origin-form-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-partial-uri-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "partial-uri"))) (let ((__function__ 'http-cst-partial-uri-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-partial-uri-conc (b* ((cstss (http-cst-partial-uri-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-partial-uri-conc-match (implies (http-cst-matchp cst "partial-uri") (b* ((cstss (http-cst-partial-uri-conc cst))) (http-cst-list-list-conc-matchp cstss "relative-part [ \"?\" query ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-partial-uri-conc-of-tree-fix-cst (equal (http-cst-partial-uri-conc (tree-fix cst)) (http-cst-partial-uri-conc cst)))
Theorem:
(defthm http-cst-partial-uri-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-partial-uri-conc cst) (http-cst-partial-uri-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol"))) (let ((__function__ 'http-cst-protocol-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-protocol-conc (b* ((cstss (http-cst-protocol-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-conc-match (implies (http-cst-matchp cst "protocol") (b* ((cstss (http-cst-protocol-conc cst))) (http-cst-list-list-conc-matchp cstss "protocol-name [ \"/\" protocol-version ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-conc-of-tree-fix-cst (equal (http-cst-protocol-conc (tree-fix cst)) (http-cst-protocol-conc cst)))
Theorem:
(defthm http-cst-protocol-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-conc cst) (http-cst-protocol-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-name"))) (let ((__function__ 'http-cst-protocol-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-protocol-name-conc (b* ((cstss (http-cst-protocol-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-match (implies (http-cst-matchp cst "protocol-name") (b* ((cstss (http-cst-protocol-name-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-of-tree-fix-cst (equal (http-cst-protocol-name-conc (tree-fix cst)) (http-cst-protocol-name-conc cst)))
Theorem:
(defthm http-cst-protocol-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-name-conc cst) (http-cst-protocol-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-version-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-version"))) (let ((__function__ 'http-cst-protocol-version-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-protocol-version-conc (b* ((cstss (http-cst-protocol-version-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-match (implies (http-cst-matchp cst "protocol-version") (b* ((cstss (http-cst-protocol-version-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-of-tree-fix-cst (equal (http-cst-protocol-version-conc (tree-fix cst)) (http-cst-protocol-version-conc cst)))
Theorem:
(defthm http-cst-protocol-version-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-version-conc cst) (http-cst-protocol-version-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-pseudonym-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "pseudonym"))) (let ((__function__ 'http-cst-pseudonym-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-pseudonym-conc (b* ((cstss (http-cst-pseudonym-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-match (implies (http-cst-matchp cst "pseudonym") (b* ((cstss (http-cst-pseudonym-conc cst))) (http-cst-list-list-conc-matchp cstss "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-of-tree-fix-cst (equal (http-cst-pseudonym-conc (tree-fix cst)) (http-cst-pseudonym-conc cst)))
Theorem:
(defthm http-cst-pseudonym-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-pseudonym-conc cst) (http-cst-pseudonym-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-quoted-pair-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "quoted-pair"))) (let ((__function__ 'http-cst-quoted-pair-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-quoted-pair-conc (b* ((cstss (http-cst-quoted-pair-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-quoted-pair-conc-match (implies (http-cst-matchp cst "quoted-pair") (b* ((cstss (http-cst-quoted-pair-conc cst))) (http-cst-list-list-conc-matchp cstss "\"\\\" ( htab / sp / vchar / obs-text )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-quoted-pair-conc-of-tree-fix-cst (equal (http-cst-quoted-pair-conc (tree-fix cst)) (http-cst-quoted-pair-conc cst)))
Theorem:
(defthm http-cst-quoted-pair-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-quoted-pair-conc cst) (http-cst-quoted-pair-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-quoted-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "quoted-string"))) (let ((__function__ 'http-cst-quoted-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-quoted-string-conc (b* ((cstss (http-cst-quoted-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-quoted-string-conc-match (implies (http-cst-matchp cst "quoted-string") (b* ((cstss (http-cst-quoted-string-conc cst))) (http-cst-list-list-conc-matchp cstss "dquote *( qdtext / quoted-pair ) dquote"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-quoted-string-conc-of-tree-fix-cst (equal (http-cst-quoted-string-conc (tree-fix cst)) (http-cst-quoted-string-conc cst)))
Theorem:
(defthm http-cst-quoted-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-quoted-string-conc cst) (http-cst-quoted-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-reason-phrase-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "reason-phrase"))) (let ((__function__ 'http-cst-reason-phrase-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-reason-phrase-conc (b* ((cstss (http-cst-reason-phrase-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-reason-phrase-conc-match (implies (http-cst-matchp cst "reason-phrase") (b* ((cstss (http-cst-reason-phrase-conc cst))) (http-cst-list-list-conc-matchp cstss "*( htab / sp / vchar / obs-text )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-reason-phrase-conc-of-tree-fix-cst (equal (http-cst-reason-phrase-conc (tree-fix cst)) (http-cst-reason-phrase-conc cst)))
Theorem:
(defthm http-cst-reason-phrase-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-reason-phrase-conc cst) (http-cst-reason-phrase-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-received-protocol-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "received-protocol"))) (let ((__function__ 'http-cst-received-protocol-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-received-protocol-conc (b* ((cstss (http-cst-received-protocol-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-received-protocol-conc-match (implies (http-cst-matchp cst "received-protocol") (b* ((cstss (http-cst-received-protocol-conc cst))) (http-cst-list-list-conc-matchp cstss "[ protocol-name \"/\" ] protocol-version"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-received-protocol-conc-of-tree-fix-cst (equal (http-cst-received-protocol-conc (tree-fix cst)) (http-cst-received-protocol-conc cst)))
Theorem:
(defthm http-cst-received-protocol-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-received-protocol-conc cst) (http-cst-received-protocol-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "request-line"))) (let ((__function__ 'http-cst-request-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-request-line-conc (b* ((cstss (http-cst-request-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-line-conc-match (implies (http-cst-matchp cst "request-line") (b* ((cstss (http-cst-request-line-conc cst))) (http-cst-list-list-conc-matchp cstss "method sp request-target sp http-version crlf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-line-conc-of-tree-fix-cst (equal (http-cst-request-line-conc (tree-fix cst)) (http-cst-request-line-conc cst)))
Theorem:
(defthm http-cst-request-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-line-conc cst) (http-cst-request-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)))) (let ((__function__ 'http-cst-request-target-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-request-target-conc1 (b* ((cstss (http-cst-request-target-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)) (b* ((cstss (http-cst-request-target-conc1 cst))) (http-cst-list-list-conc-matchp cstss "origin-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-of-tree-fix-cst (equal (http-cst-request-target-conc1 (tree-fix cst)) (http-cst-request-target-conc1 cst)))
Theorem:
(defthm http-cst-request-target-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc1 cst) (http-cst-request-target-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)))) (let ((__function__ 'http-cst-request-target-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-request-target-conc2 (b* ((cstss (http-cst-request-target-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)) (b* ((cstss (http-cst-request-target-conc2 cst))) (http-cst-list-list-conc-matchp cstss "absolute-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-of-tree-fix-cst (equal (http-cst-request-target-conc2 (tree-fix cst)) (http-cst-request-target-conc2 cst)))
Theorem:
(defthm http-cst-request-target-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc2 cst) (http-cst-request-target-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)))) (let ((__function__ 'http-cst-request-target-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-request-target-conc3 (b* ((cstss (http-cst-request-target-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)) (b* ((cstss (http-cst-request-target-conc3 cst))) (http-cst-list-list-conc-matchp cstss "authority-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-of-tree-fix-cst (equal (http-cst-request-target-conc3 (tree-fix cst)) (http-cst-request-target-conc3 cst)))
Theorem:
(defthm http-cst-request-target-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc3 cst) (http-cst-request-target-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)))) (let ((__function__ 'http-cst-request-target-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-request-target-conc4 (b* ((cstss (http-cst-request-target-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)) (b* ((cstss (http-cst-request-target-conc4 cst))) (http-cst-list-list-conc-matchp cstss "asterisk-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-of-tree-fix-cst (equal (http-cst-request-target-conc4 (tree-fix cst)) (http-cst-request-target-conc4 cst)))
Theorem:
(defthm http-cst-request-target-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc4 cst) (http-cst-request-target-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)))) (let ((__function__ 'http-cst-start-line-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-start-line-conc1 (b* ((cstss (http-cst-start-line-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)) (b* ((cstss (http-cst-start-line-conc1 cst))) (http-cst-list-list-conc-matchp cstss "request-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-of-tree-fix-cst (equal (http-cst-start-line-conc1 (tree-fix cst)) (http-cst-start-line-conc1 cst)))
Theorem:
(defthm http-cst-start-line-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc1 cst) (http-cst-start-line-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)))) (let ((__function__ 'http-cst-start-line-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-start-line-conc2 (b* ((cstss (http-cst-start-line-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)) (b* ((cstss (http-cst-start-line-conc2 cst))) (http-cst-list-list-conc-matchp cstss "status-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-of-tree-fix-cst (equal (http-cst-start-line-conc2 (tree-fix cst)) (http-cst-start-line-conc2 cst)))
Theorem:
(defthm http-cst-start-line-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc2 cst) (http-cst-start-line-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-status-code-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "status-code"))) (let ((__function__ 'http-cst-status-code-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-status-code-conc (b* ((cstss (http-cst-status-code-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-status-code-conc-match (implies (http-cst-matchp cst "status-code") (b* ((cstss (http-cst-status-code-conc cst))) (http-cst-list-list-conc-matchp cstss "3digit"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-status-code-conc-of-tree-fix-cst (equal (http-cst-status-code-conc (tree-fix cst)) (http-cst-status-code-conc cst)))
Theorem:
(defthm http-cst-status-code-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-status-code-conc cst) (http-cst-status-code-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-status-line-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "status-line"))) (let ((__function__ 'http-cst-status-line-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-status-line-conc (b* ((cstss (http-cst-status-line-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-status-line-conc-match (implies (http-cst-matchp cst "status-line") (b* ((cstss (http-cst-status-line-conc cst))) (http-cst-list-list-conc-matchp cstss "http-version sp status-code sp reason-phrase crlf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-status-line-conc-of-tree-fix-cst (equal (http-cst-status-line-conc (tree-fix cst)) (http-cst-status-line-conc cst)))
Theorem:
(defthm http-cst-status-line-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-status-line-conc cst) (http-cst-status-line-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-t-ranking-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "t-ranking"))) (let ((__function__ 'http-cst-t-ranking-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-t-ranking-conc (b* ((cstss (http-cst-t-ranking-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-t-ranking-conc-match (implies (http-cst-matchp cst "t-ranking") (b* ((cstss (http-cst-t-ranking-conc cst))) (http-cst-list-list-conc-matchp cstss "ows \";\" ows \"q=\" rank"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-t-ranking-conc-of-tree-fix-cst (equal (http-cst-t-ranking-conc (tree-fix cst)) (http-cst-t-ranking-conc cst)))
Theorem:
(defthm http-cst-t-ranking-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-t-ranking-conc cst) (http-cst-t-ranking-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-token-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "token"))) (let ((__function__ 'http-cst-token-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-token-conc (b* ((cstss (http-cst-token-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-token-conc-match (implies (http-cst-matchp cst "token") (b* ((cstss (http-cst-token-conc cst))) (http-cst-list-list-conc-matchp cstss "1*tchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-token-conc-of-tree-fix-cst (equal (http-cst-token-conc (tree-fix cst)) (http-cst-token-conc cst)))
Theorem:
(defthm http-cst-token-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-token-conc cst) (http-cst-token-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-trailer-part-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "trailer-part"))) (let ((__function__ 'http-cst-trailer-part-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-trailer-part-conc (b* ((cstss (http-cst-trailer-part-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-trailer-part-conc-match (implies (http-cst-matchp cst "trailer-part") (b* ((cstss (http-cst-trailer-part-conc cst))) (http-cst-list-list-conc-matchp cstss "*( header-field crlf )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-trailer-part-conc-of-tree-fix-cst (equal (http-cst-trailer-part-conc (tree-fix cst)) (http-cst-trailer-part-conc cst)))
Theorem:
(defthm http-cst-trailer-part-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-trailer-part-conc cst) (http-cst-trailer-part-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-transfer-extension-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "transfer-extension"))) (let ((__function__ 'http-cst-transfer-extension-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-transfer-extension-conc (b* ((cstss (http-cst-transfer-extension-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-extension-conc-match (implies (http-cst-matchp cst "transfer-extension") (b* ((cstss (http-cst-transfer-extension-conc cst))) (http-cst-list-list-conc-matchp cstss "token *( ows \";\" ows transfer-parameter )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-extension-conc-of-tree-fix-cst (equal (http-cst-transfer-extension-conc (tree-fix cst)) (http-cst-transfer-extension-conc cst)))
Theorem:
(defthm http-cst-transfer-extension-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-transfer-extension-conc cst) (http-cst-transfer-extension-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-transfer-parameter-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "transfer-parameter"))) (let ((__function__ 'http-cst-transfer-parameter-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-transfer-parameter-conc (b* ((cstss (http-cst-transfer-parameter-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-parameter-conc-match (implies (http-cst-matchp cst "transfer-parameter") (b* ((cstss (http-cst-transfer-parameter-conc cst))) (http-cst-list-list-conc-matchp cstss "token bws \"=\" bws ( token / quoted-string )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-transfer-parameter-conc-of-tree-fix-cst (equal (http-cst-transfer-parameter-conc (tree-fix cst)) (http-cst-transfer-parameter-conc cst)))
Theorem:
(defthm http-cst-transfer-parameter-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-transfer-parameter-conc cst) (http-cst-transfer-parameter-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-absolute-uri-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "absolute-uri"))) (let ((__function__ 'http-cst-absolute-uri-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-absolute-uri-conc (b* ((cstss (http-cst-absolute-uri-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-uri-conc-match (implies (http-cst-matchp cst "absolute-uri") (b* ((cstss (http-cst-absolute-uri-conc cst))) (http-cst-list-list-conc-matchp cstss "scheme \":\" hier-part [ \"?\" query ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-uri-conc-of-tree-fix-cst (equal (http-cst-absolute-uri-conc (tree-fix cst)) (http-cst-absolute-uri-conc cst)))
Theorem:
(defthm http-cst-absolute-uri-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-absolute-uri-conc cst) (http-cst-absolute-uri-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-authority-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "authority"))) (let ((__function__ 'http-cst-authority-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-authority-conc (b* ((cstss (http-cst-authority-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-conc-match (implies (http-cst-matchp cst "authority") (b* ((cstss (http-cst-authority-conc cst))) (http-cst-list-list-conc-matchp cstss "[ userinfo \"@\" ] uri-host [ \":\" port ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-conc-of-tree-fix-cst (equal (http-cst-authority-conc (tree-fix cst)) (http-cst-authority-conc cst)))
Theorem:
(defthm http-cst-authority-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-authority-conc cst) (http-cst-authority-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-fragment-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "fragment"))) (let ((__function__ 'http-cst-fragment-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-fragment-conc (b* ((cstss (http-cst-fragment-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-fragment-conc-match (implies (http-cst-matchp cst "fragment") (b* ((cstss (http-cst-fragment-conc cst))) (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-fragment-conc-of-tree-fix-cst (equal (http-cst-fragment-conc (tree-fix cst)) (http-cst-fragment-conc cst)))
Theorem:
(defthm http-cst-fragment-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-fragment-conc cst) (http-cst-fragment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-path-abempty-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "path-abempty"))) (let ((__function__ 'http-cst-path-abempty-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-path-abempty-conc (b* ((cstss (http-cst-path-abempty-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-abempty-conc-match (implies (http-cst-matchp cst "path-abempty") (b* ((cstss (http-cst-path-abempty-conc cst))) (http-cst-list-list-conc-matchp cstss "*( \"/\" segment )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-abempty-conc-of-tree-fix-cst (equal (http-cst-path-abempty-conc (tree-fix cst)) (http-cst-path-abempty-conc cst)))
Theorem:
(defthm http-cst-path-abempty-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-path-abempty-conc cst) (http-cst-path-abempty-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-path-absolute-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "path-absolute"))) (let ((__function__ 'http-cst-path-absolute-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-path-absolute-conc (b* ((cstss (http-cst-path-absolute-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-absolute-conc-match (implies (http-cst-matchp cst "path-absolute") (b* ((cstss (http-cst-path-absolute-conc cst))) (http-cst-list-list-conc-matchp cstss "\"/\" [ segment-nz *( \"/\" segment ) ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-absolute-conc-of-tree-fix-cst (equal (http-cst-path-absolute-conc (tree-fix cst)) (http-cst-path-absolute-conc cst)))
Theorem:
(defthm http-cst-path-absolute-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-path-absolute-conc cst) (http-cst-path-absolute-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-path-empty-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "path-empty"))) (let ((__function__ 'http-cst-path-empty-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-path-empty-conc (b* ((cstss (http-cst-path-empty-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-empty-conc-match (implies (http-cst-matchp cst "path-empty") (b* ((cstss (http-cst-path-empty-conc cst))) (http-cst-list-list-conc-matchp cstss "0<pchar>"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-empty-conc-of-tree-fix-cst (equal (http-cst-path-empty-conc (tree-fix cst)) (http-cst-path-empty-conc cst)))
Theorem:
(defthm http-cst-path-empty-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-path-empty-conc cst) (http-cst-path-empty-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-path-rootless-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "path-rootless"))) (let ((__function__ 'http-cst-path-rootless-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-path-rootless-conc (b* ((cstss (http-cst-path-rootless-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-rootless-conc-match (implies (http-cst-matchp cst "path-rootless") (b* ((cstss (http-cst-path-rootless-conc cst))) (http-cst-list-list-conc-matchp cstss "segment-nz *( \"/\" segment )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-rootless-conc-of-tree-fix-cst (equal (http-cst-path-rootless-conc (tree-fix cst)) (http-cst-path-rootless-conc cst)))
Theorem:
(defthm http-cst-path-rootless-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-path-rootless-conc cst) (http-cst-path-rootless-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-pct-encoded-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "pct-encoded"))) (let ((__function__ 'http-cst-pct-encoded-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-pct-encoded-conc (b* ((cstss (http-cst-pct-encoded-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pct-encoded-conc-match (implies (http-cst-matchp cst "pct-encoded") (b* ((cstss (http-cst-pct-encoded-conc cst))) (http-cst-list-list-conc-matchp cstss "\"%\" hexdig hexdig"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pct-encoded-conc-of-tree-fix-cst (equal (http-cst-pct-encoded-conc (tree-fix cst)) (http-cst-pct-encoded-conc cst)))
Theorem:
(defthm http-cst-pct-encoded-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-pct-encoded-conc cst) (http-cst-pct-encoded-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-port-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "port"))) (let ((__function__ 'http-cst-port-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-port-conc (b* ((cstss (http-cst-port-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-port-conc-match (implies (http-cst-matchp cst "port") (b* ((cstss (http-cst-port-conc cst))) (http-cst-list-list-conc-matchp cstss "*digit"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-port-conc-of-tree-fix-cst (equal (http-cst-port-conc (tree-fix cst)) (http-cst-port-conc cst)))
Theorem:
(defthm http-cst-port-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-port-conc cst) (http-cst-port-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-query-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "query"))) (let ((__function__ 'http-cst-query-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-query-conc (b* ((cstss (http-cst-query-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-query-conc-match (implies (http-cst-matchp cst "query") (b* ((cstss (http-cst-query-conc cst))) (http-cst-list-list-conc-matchp cstss "*( pchar / \"/\" / \"?\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-query-conc-of-tree-fix-cst (equal (http-cst-query-conc (tree-fix cst)) (http-cst-query-conc cst)))
Theorem:
(defthm http-cst-query-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-query-conc cst) (http-cst-query-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-path-noscheme-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "path-noscheme"))) (let ((__function__ 'http-cst-path-noscheme-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-path-noscheme-conc (b* ((cstss (http-cst-path-noscheme-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-noscheme-conc-match (implies (http-cst-matchp cst "path-noscheme") (b* ((cstss (http-cst-path-noscheme-conc cst))) (http-cst-list-list-conc-matchp cstss "segment-nz-nc *( \"/\" segment )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-path-noscheme-conc-of-tree-fix-cst (equal (http-cst-path-noscheme-conc (tree-fix cst)) (http-cst-path-noscheme-conc cst)))
Theorem:
(defthm http-cst-path-noscheme-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-path-noscheme-conc cst) (http-cst-path-noscheme-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-scheme-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "scheme"))) (let ((__function__ 'http-cst-scheme-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-scheme-conc (b* ((cstss (http-cst-scheme-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-scheme-conc-match (implies (http-cst-matchp cst "scheme") (b* ((cstss (http-cst-scheme-conc cst))) (http-cst-list-list-conc-matchp cstss "alpha *( alpha / digit / \"+\" / \"-\" / \".\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-scheme-conc-of-tree-fix-cst (equal (http-cst-scheme-conc (tree-fix cst)) (http-cst-scheme-conc cst)))
Theorem:
(defthm http-cst-scheme-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-scheme-conc cst) (http-cst-scheme-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-segment-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "segment"))) (let ((__function__ 'http-cst-segment-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-segment-conc (b* ((cstss (http-cst-segment-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-conc-match (implies (http-cst-matchp cst "segment") (b* ((cstss (http-cst-segment-conc cst))) (http-cst-list-list-conc-matchp cstss "*pchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-conc-of-tree-fix-cst (equal (http-cst-segment-conc (tree-fix cst)) (http-cst-segment-conc cst)))
Theorem:
(defthm http-cst-segment-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-segment-conc cst) (http-cst-segment-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-segment-nz-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "segment-nz"))) (let ((__function__ 'http-cst-segment-nz-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-segment-nz-conc (b* ((cstss (http-cst-segment-nz-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-nz-conc-match (implies (http-cst-matchp cst "segment-nz") (b* ((cstss (http-cst-segment-nz-conc cst))) (http-cst-list-list-conc-matchp cstss "1*pchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-nz-conc-of-tree-fix-cst (equal (http-cst-segment-nz-conc (tree-fix cst)) (http-cst-segment-nz-conc cst)))
Theorem:
(defthm http-cst-segment-nz-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-segment-nz-conc cst) (http-cst-segment-nz-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-segment-nz-nc-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "segment-nz-nc"))) (let ((__function__ 'http-cst-segment-nz-nc-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-segment-nz-nc-conc (b* ((cstss (http-cst-segment-nz-nc-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-nz-nc-conc-match (implies (http-cst-matchp cst "segment-nz-nc") (b* ((cstss (http-cst-segment-nz-nc-conc cst))) (http-cst-list-list-conc-matchp cstss "1*( unreserved / pct-encoded / sub-delims / \"@\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-segment-nz-nc-conc-of-tree-fix-cst (equal (http-cst-segment-nz-nc-conc (tree-fix cst)) (http-cst-segment-nz-nc-conc cst)))
Theorem:
(defthm http-cst-segment-nz-nc-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-segment-nz-nc-conc cst) (http-cst-segment-nz-nc-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)))) (let ((__function__ 'http-cst-uri-host-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-uri-host-conc1 (b* ((cstss (http-cst-uri-host-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)) (b* ((cstss (http-cst-uri-host-conc1 cst))) (http-cst-list-list-conc-matchp cstss "ip-literal"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-of-tree-fix-cst (equal (http-cst-uri-host-conc1 (tree-fix cst)) (http-cst-uri-host-conc1 cst)))
Theorem:
(defthm http-cst-uri-host-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc1 cst) (http-cst-uri-host-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)))) (let ((__function__ 'http-cst-uri-host-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-uri-host-conc2 (b* ((cstss (http-cst-uri-host-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)) (b* ((cstss (http-cst-uri-host-conc2 cst))) (http-cst-list-list-conc-matchp cstss "ipv4address"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-of-tree-fix-cst (equal (http-cst-uri-host-conc2 (tree-fix cst)) (http-cst-uri-host-conc2 cst)))
Theorem:
(defthm http-cst-uri-host-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc2 cst) (http-cst-uri-host-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)))) (let ((__function__ 'http-cst-uri-host-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-uri-host-conc3 (b* ((cstss (http-cst-uri-host-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)) (b* ((cstss (http-cst-uri-host-conc3 cst))) (http-cst-list-list-conc-matchp cstss "reg-name"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-of-tree-fix-cst (equal (http-cst-uri-host-conc3 (tree-fix cst)) (http-cst-uri-host-conc3 cst)))
Theorem:
(defthm http-cst-uri-host-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc3 cst) (http-cst-uri-host-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-ip-literal-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "ip-literal"))) (let ((__function__ 'http-cst-ip-literal-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-ip-literal-conc (b* ((cstss (http-cst-ip-literal-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ip-literal-conc-match (implies (http-cst-matchp cst "ip-literal") (b* ((cstss (http-cst-ip-literal-conc cst))) (http-cst-list-list-conc-matchp cstss "\"[\" ( ipv6address / ipvfuture ) \"]\""))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ip-literal-conc-of-tree-fix-cst (equal (http-cst-ip-literal-conc (tree-fix cst)) (http-cst-ip-literal-conc cst)))
Theorem:
(defthm http-cst-ip-literal-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-ip-literal-conc cst) (http-cst-ip-literal-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-ipv4address-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "ipv4address"))) (let ((__function__ 'http-cst-ipv4address-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-ipv4address-conc (b* ((cstss (http-cst-ipv4address-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ipv4address-conc-match (implies (http-cst-matchp cst "ipv4address") (b* ((cstss (http-cst-ipv4address-conc cst))) (http-cst-list-list-conc-matchp cstss "dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ipv4address-conc-of-tree-fix-cst (equal (http-cst-ipv4address-conc (tree-fix cst)) (http-cst-ipv4address-conc cst)))
Theorem:
(defthm http-cst-ipv4address-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-ipv4address-conc cst) (http-cst-ipv4address-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-h16-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "h16"))) (let ((__function__ 'http-cst-h16-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-h16-conc (b* ((cstss (http-cst-h16-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-h16-conc-match (implies (http-cst-matchp cst "h16") (b* ((cstss (http-cst-h16-conc cst))) (http-cst-list-list-conc-matchp cstss "1*4hexdig"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-h16-conc-of-tree-fix-cst (equal (http-cst-h16-conc (tree-fix cst)) (http-cst-h16-conc cst)))
Theorem:
(defthm http-cst-h16-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-h16-conc cst) (http-cst-h16-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-ipvfuture-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "ipvfuture"))) (let ((__function__ 'http-cst-ipvfuture-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-ipvfuture-conc (b* ((cstss (http-cst-ipvfuture-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ipvfuture-conc-match (implies (http-cst-matchp cst "ipvfuture") (b* ((cstss (http-cst-ipvfuture-conc cst))) (http-cst-list-list-conc-matchp cstss "\"v\" 1*hexdig \".\" 1*( unreserved / sub-delims / \":\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-ipvfuture-conc-of-tree-fix-cst (equal (http-cst-ipvfuture-conc (tree-fix cst)) (http-cst-ipvfuture-conc cst)))
Theorem:
(defthm http-cst-ipvfuture-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-ipvfuture-conc cst) (http-cst-ipvfuture-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-reg-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "reg-name"))) (let ((__function__ 'http-cst-reg-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-reg-name-conc (b* ((cstss (http-cst-reg-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-reg-name-conc-match (implies (http-cst-matchp cst "reg-name") (b* ((cstss (http-cst-reg-name-conc cst))) (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-reg-name-conc-of-tree-fix-cst (equal (http-cst-reg-name-conc (tree-fix cst)) (http-cst-reg-name-conc cst)))
Theorem:
(defthm http-cst-reg-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-reg-name-conc cst) (http-cst-reg-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-userinfo-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "userinfo"))) (let ((__function__ 'http-cst-userinfo-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-userinfo-conc (b* ((cstss (http-cst-userinfo-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-userinfo-conc-match (implies (http-cst-matchp cst "userinfo") (b* ((cstss (http-cst-userinfo-conc cst))) (http-cst-list-list-conc-matchp cstss "*( unreserved / pct-encoded / sub-delims / \":\" )"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-userinfo-conc-of-tree-fix-cst (equal (http-cst-userinfo-conc (tree-fix cst)) (http-cst-userinfo-conc cst)))
Theorem:
(defthm http-cst-userinfo-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-userinfo-conc cst) (http-cst-userinfo-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-crlf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "crlf"))) (let ((__function__ 'http-cst-crlf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-crlf-conc (b* ((cstss (http-cst-crlf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-crlf-conc-match (implies (http-cst-matchp cst "crlf") (b* ((cstss (http-cst-crlf-conc cst))) (http-cst-list-list-conc-matchp cstss "cr lf"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-crlf-conc-of-tree-fix-cst (equal (http-cst-crlf-conc (tree-fix cst)) (http-cst-crlf-conc cst)))
Theorem:
(defthm http-cst-crlf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-crlf-conc cst) (http-cst-crlf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-cr-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "cr"))) (let ((__function__ 'http-cst-cr-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-cr-conc (b* ((cstss (http-cst-cr-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-match (implies (http-cst-matchp cst "cr") (b* ((cstss (http-cst-cr-conc cst))) (http-cst-list-list-conc-matchp cstss "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-of-tree-fix-cst (equal (http-cst-cr-conc (tree-fix cst)) (http-cst-cr-conc cst)))
Theorem:
(defthm http-cst-cr-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-cr-conc cst) (http-cst-cr-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-digit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "digit"))) (let ((__function__ 'http-cst-digit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-digit-conc (b* ((cstss (http-cst-digit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-match (implies (http-cst-matchp cst "digit") (b* ((cstss (http-cst-digit-conc cst))) (http-cst-list-list-conc-matchp cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-of-tree-fix-cst (equal (http-cst-digit-conc (tree-fix cst)) (http-cst-digit-conc cst)))
Theorem:
(defthm http-cst-digit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-digit-conc cst) (http-cst-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-dquote-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "dquote"))) (let ((__function__ 'http-cst-dquote-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-dquote-conc (b* ((cstss (http-cst-dquote-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-match (implies (http-cst-matchp cst "dquote") (b* ((cstss (http-cst-dquote-conc cst))) (http-cst-list-list-conc-matchp cstss "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-of-tree-fix-cst (equal (http-cst-dquote-conc (tree-fix cst)) (http-cst-dquote-conc cst)))
Theorem:
(defthm http-cst-dquote-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-dquote-conc cst) (http-cst-dquote-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-htab-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "htab"))) (let ((__function__ 'http-cst-htab-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-htab-conc (b* ((cstss (http-cst-htab-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-match (implies (http-cst-matchp cst "htab") (b* ((cstss (http-cst-htab-conc cst))) (http-cst-list-list-conc-matchp cstss "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-of-tree-fix-cst (equal (http-cst-htab-conc (tree-fix cst)) (http-cst-htab-conc cst)))
Theorem:
(defthm http-cst-htab-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-htab-conc cst) (http-cst-htab-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-lf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "lf"))) (let ((__function__ 'http-cst-lf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-lf-conc (b* ((cstss (http-cst-lf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-match (implies (http-cst-matchp cst "lf") (b* ((cstss (http-cst-lf-conc cst))) (http-cst-list-list-conc-matchp cstss "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-of-tree-fix-cst (equal (http-cst-lf-conc (tree-fix cst)) (http-cst-lf-conc cst)))
Theorem:
(defthm http-cst-lf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-lf-conc cst) (http-cst-lf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-octet-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "octet"))) (let ((__function__ 'http-cst-octet-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-octet-conc (b* ((cstss (http-cst-octet-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-match (implies (http-cst-matchp cst "octet") (b* ((cstss (http-cst-octet-conc cst))) (http-cst-list-list-conc-matchp cstss "%x0-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-of-tree-fix-cst (equal (http-cst-octet-conc (tree-fix cst)) (http-cst-octet-conc cst)))
Theorem:
(defthm http-cst-octet-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-octet-conc cst) (http-cst-octet-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-sp-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "sp"))) (let ((__function__ 'http-cst-sp-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-sp-conc (b* ((cstss (http-cst-sp-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-match (implies (http-cst-matchp cst "sp") (b* ((cstss (http-cst-sp-conc cst))) (http-cst-list-list-conc-matchp cstss "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-of-tree-fix-cst (equal (http-cst-sp-conc (tree-fix cst)) (http-cst-sp-conc cst)))
Theorem:
(defthm http-cst-sp-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-sp-conc cst) (http-cst-sp-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-vchar-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "vchar"))) (let ((__function__ 'http-cst-vchar-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-http-cst-vchar-conc (b* ((cstss (http-cst-vchar-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-match (implies (http-cst-matchp cst "vchar") (b* ((cstss (http-cst-vchar-conc cst))) (http-cst-list-list-conc-matchp cstss "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-of-tree-fix-cst (equal (http-cst-vchar-conc (tree-fix cst)) (http-cst-vchar-conc cst)))
Theorem:
(defthm http-cst-vchar-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-vchar-conc cst) (http-cst-vchar-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-bws-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "bws"))) (let ((__function__ 'http-cst-bws-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-bws-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-bws-conc-rep (b* ((csts (http-cst-bws-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-rep-match (implies (http-cst-matchp cst "bws") (b* ((csts (http-cst-bws-conc-rep cst))) (http-cst-list-rep-matchp csts "ows"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-rep-of-tree-fix-cst (equal (http-cst-bws-conc-rep (tree-fix cst)) (http-cst-bws-conc-rep cst)))
Theorem:
(defthm http-cst-bws-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-bws-conc-rep cst) (http-cst-bws-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-name"))) (let ((__function__ 'http-cst-http-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-http-name-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-http-name-conc-rep (b* ((csts (http-cst-http-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-rep-match (implies (http-cst-matchp cst "http-name") (b* ((csts (http-cst-http-name-conc-rep cst))) (http-cst-list-rep-matchp csts "%x48.54.54.50"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-rep-of-tree-fix-cst (equal (http-cst-http-name-conc-rep (tree-fix cst)) (http-cst-http-name-conc-rep cst)))
Theorem:
(defthm http-cst-http-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-name-conc-rep cst) (http-cst-http-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-te-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "te"))) (let ((__function__ 'http-cst-te-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-te-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-te-conc-rep (b* ((csts (http-cst-te-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-rep-match (implies (http-cst-matchp cst "te") (b* ((csts (http-cst-te-conc-rep cst))) (http-cst-list-rep-matchp csts "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-rep-of-tree-fix-cst (equal (http-cst-te-conc-rep (tree-fix cst)) (http-cst-te-conc-rep cst)))
Theorem:
(defthm http-cst-te-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-te-conc-rep cst) (http-cst-te-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-absolute-form-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "absolute-form"))) (let ((__function__ 'http-cst-absolute-form-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-absolute-form-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-absolute-form-conc-rep (b* ((csts (http-cst-absolute-form-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-rep-match (implies (http-cst-matchp cst "absolute-form") (b* ((csts (http-cst-absolute-form-conc-rep cst))) (http-cst-list-rep-matchp csts "absolute-uri"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-rep-of-tree-fix-cst (equal (http-cst-absolute-form-conc-rep (tree-fix cst)) (http-cst-absolute-form-conc-rep cst)))
Theorem:
(defthm http-cst-absolute-form-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-absolute-form-conc-rep cst) (http-cst-absolute-form-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-asterisk-form-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "asterisk-form"))) (let ((__function__ 'http-cst-asterisk-form-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-asterisk-form-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-asterisk-form-conc-rep (b* ((csts (http-cst-asterisk-form-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-rep-match (implies (http-cst-matchp cst "asterisk-form") (b* ((csts (http-cst-asterisk-form-conc-rep cst))) (http-cst-list-rep-matchp csts "\"*\""))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-rep-of-tree-fix-cst (equal (http-cst-asterisk-form-conc-rep (tree-fix cst)) (http-cst-asterisk-form-conc-rep cst)))
Theorem:
(defthm http-cst-asterisk-form-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-asterisk-form-conc-rep cst) (http-cst-asterisk-form-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-authority-form-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "authority-form"))) (let ((__function__ 'http-cst-authority-form-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-authority-form-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-authority-form-conc-rep (b* ((csts (http-cst-authority-form-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-rep-match (implies (http-cst-matchp cst "authority-form") (b* ((csts (http-cst-authority-form-conc-rep cst))) (http-cst-list-rep-matchp csts "authority"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-rep-of-tree-fix-cst (equal (http-cst-authority-form-conc-rep (tree-fix cst)) (http-cst-authority-form-conc-rep cst)))
Theorem:
(defthm http-cst-authority-form-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-authority-form-conc-rep cst) (http-cst-authority-form-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-ext-name"))) (let ((__function__ 'http-cst-chunk-ext-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-chunk-ext-name-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-chunk-ext-name-conc-rep (b* ((csts (http-cst-chunk-ext-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-match (implies (http-cst-matchp cst "chunk-ext-name") (b* ((csts (http-cst-chunk-ext-name-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-of-tree-fix-cst (equal (http-cst-chunk-ext-name-conc-rep (tree-fix cst)) (http-cst-chunk-ext-name-conc-rep cst)))
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-name-conc-rep cst) (http-cst-chunk-ext-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)))) (let ((__function__ 'http-cst-chunk-ext-val-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-chunk-ext-val-conc1 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-chunk-ext-val-conc1-rep (b* ((csts (http-cst-chunk-ext-val-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)) (b* ((csts (http-cst-chunk-ext-val-conc1-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc1-rep (tree-fix cst)) (http-cst-chunk-ext-val-conc1-rep cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc1-rep cst) (http-cst-chunk-ext-val-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)))) (let ((__function__ 'http-cst-chunk-ext-val-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-chunk-ext-val-conc2 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-chunk-ext-val-conc2-rep (b* ((csts (http-cst-chunk-ext-val-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)) (b* ((csts (http-cst-chunk-ext-val-conc2-rep cst))) (http-cst-list-rep-matchp csts "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc2-rep (tree-fix cst)) (http-cst-chunk-ext-val-conc2-rep cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc2-rep cst) (http-cst-chunk-ext-val-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-connection-option-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "connection-option"))) (let ((__function__ 'http-cst-connection-option-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-connection-option-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-connection-option-conc-rep (b* ((csts (http-cst-connection-option-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-rep-match (implies (http-cst-matchp cst "connection-option") (b* ((csts (http-cst-connection-option-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-rep-of-tree-fix-cst (equal (http-cst-connection-option-conc-rep (tree-fix cst)) (http-cst-connection-option-conc-rep cst)))
Theorem:
(defthm http-cst-connection-option-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-connection-option-conc-rep cst) (http-cst-connection-option-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-name"))) (let ((__function__ 'http-cst-field-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-field-name-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-field-name-conc-rep (b* ((csts (http-cst-field-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-rep-match (implies (http-cst-matchp cst "field-name") (b* ((csts (http-cst-field-name-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-rep-of-tree-fix-cst (equal (http-cst-field-name-conc-rep (tree-fix cst)) (http-cst-field-name-conc-rep cst)))
Theorem:
(defthm http-cst-field-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-name-conc-rep cst) (http-cst-field-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)))) (let ((__function__ 'http-cst-field-vchar-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-field-vchar-conc1 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-field-vchar-conc1-rep (b* ((csts (http-cst-field-vchar-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-rep-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)) (b* ((csts (http-cst-field-vchar-conc1-rep cst))) (http-cst-list-rep-matchp csts "vchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-rep-of-tree-fix-cst (equal (http-cst-field-vchar-conc1-rep (tree-fix cst)) (http-cst-field-vchar-conc1-rep cst)))
Theorem:
(defthm http-cst-field-vchar-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc1-rep cst) (http-cst-field-vchar-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)))) (let ((__function__ 'http-cst-field-vchar-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-field-vchar-conc2 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-field-vchar-conc2-rep (b* ((csts (http-cst-field-vchar-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-rep-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)) (b* ((csts (http-cst-field-vchar-conc2-rep cst))) (http-cst-list-rep-matchp csts "obs-text"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-rep-of-tree-fix-cst (equal (http-cst-field-vchar-conc2-rep (tree-fix cst)) (http-cst-field-vchar-conc2-rep cst)))
Theorem:
(defthm http-cst-field-vchar-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc2-rep cst) (http-cst-field-vchar-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-method-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "method"))) (let ((__function__ 'http-cst-method-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-method-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-method-conc-rep (b* ((csts (http-cst-method-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-rep-match (implies (http-cst-matchp cst "method") (b* ((csts (http-cst-method-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-rep-of-tree-fix-cst (equal (http-cst-method-conc-rep (tree-fix cst)) (http-cst-method-conc-rep cst)))
Theorem:
(defthm http-cst-method-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-method-conc-rep cst) (http-cst-method-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-obs-text-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "obs-text"))) (let ((__function__ 'http-cst-obs-text-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-obs-text-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-obs-text-conc-rep (b* ((csts (http-cst-obs-text-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-rep-match (implies (http-cst-matchp cst "obs-text") (b* ((csts (http-cst-obs-text-conc-rep cst))) (http-cst-list-rep-matchp csts "%x80-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-rep-of-tree-fix-cst (equal (http-cst-obs-text-conc-rep (tree-fix cst)) (http-cst-obs-text-conc-rep cst)))
Theorem:
(defthm http-cst-obs-text-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-obs-text-conc-rep cst) (http-cst-obs-text-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-name-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-name"))) (let ((__function__ 'http-cst-protocol-name-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-protocol-name-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-protocol-name-conc-rep (b* ((csts (http-cst-protocol-name-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-rep-match (implies (http-cst-matchp cst "protocol-name") (b* ((csts (http-cst-protocol-name-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-rep-of-tree-fix-cst (equal (http-cst-protocol-name-conc-rep (tree-fix cst)) (http-cst-protocol-name-conc-rep cst)))
Theorem:
(defthm http-cst-protocol-name-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-name-conc-rep cst) (http-cst-protocol-name-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-version-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-version"))) (let ((__function__ 'http-cst-protocol-version-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-protocol-version-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-protocol-version-conc-rep (b* ((csts (http-cst-protocol-version-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-rep-match (implies (http-cst-matchp cst "protocol-version") (b* ((csts (http-cst-protocol-version-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-rep-of-tree-fix-cst (equal (http-cst-protocol-version-conc-rep (tree-fix cst)) (http-cst-protocol-version-conc-rep cst)))
Theorem:
(defthm http-cst-protocol-version-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-version-conc-rep cst) (http-cst-protocol-version-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-pseudonym-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "pseudonym"))) (let ((__function__ 'http-cst-pseudonym-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-pseudonym-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-pseudonym-conc-rep (b* ((csts (http-cst-pseudonym-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-rep-match (implies (http-cst-matchp cst "pseudonym") (b* ((csts (http-cst-pseudonym-conc-rep cst))) (http-cst-list-rep-matchp csts "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-rep-of-tree-fix-cst (equal (http-cst-pseudonym-conc-rep (tree-fix cst)) (http-cst-pseudonym-conc-rep cst)))
Theorem:
(defthm http-cst-pseudonym-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-pseudonym-conc-rep cst) (http-cst-pseudonym-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)))) (let ((__function__ 'http-cst-request-target-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-request-target-conc1 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-request-target-conc1-rep (b* ((csts (http-cst-request-target-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-rep-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)) (b* ((csts (http-cst-request-target-conc1-rep cst))) (http-cst-list-rep-matchp csts "origin-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-rep-of-tree-fix-cst (equal (http-cst-request-target-conc1-rep (tree-fix cst)) (http-cst-request-target-conc1-rep cst)))
Theorem:
(defthm http-cst-request-target-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc1-rep cst) (http-cst-request-target-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)))) (let ((__function__ 'http-cst-request-target-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-request-target-conc2 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-request-target-conc2-rep (b* ((csts (http-cst-request-target-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-rep-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)) (b* ((csts (http-cst-request-target-conc2-rep cst))) (http-cst-list-rep-matchp csts "absolute-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-rep-of-tree-fix-cst (equal (http-cst-request-target-conc2-rep (tree-fix cst)) (http-cst-request-target-conc2-rep cst)))
Theorem:
(defthm http-cst-request-target-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc2-rep cst) (http-cst-request-target-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)))) (let ((__function__ 'http-cst-request-target-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-request-target-conc3 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-request-target-conc3-rep (b* ((csts (http-cst-request-target-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-rep-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)) (b* ((csts (http-cst-request-target-conc3-rep cst))) (http-cst-list-rep-matchp csts "authority-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-rep-of-tree-fix-cst (equal (http-cst-request-target-conc3-rep (tree-fix cst)) (http-cst-request-target-conc3-rep cst)))
Theorem:
(defthm http-cst-request-target-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc3-rep cst) (http-cst-request-target-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)))) (let ((__function__ 'http-cst-request-target-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-request-target-conc4 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-request-target-conc4-rep (b* ((csts (http-cst-request-target-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-rep-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)) (b* ((csts (http-cst-request-target-conc4-rep cst))) (http-cst-list-rep-matchp csts "asterisk-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-rep-of-tree-fix-cst (equal (http-cst-request-target-conc4-rep (tree-fix cst)) (http-cst-request-target-conc4-rep cst)))
Theorem:
(defthm http-cst-request-target-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc4-rep cst) (http-cst-request-target-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)))) (let ((__function__ 'http-cst-start-line-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-start-line-conc1 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-start-line-conc1-rep (b* ((csts (http-cst-start-line-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-rep-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)) (b* ((csts (http-cst-start-line-conc1-rep cst))) (http-cst-list-rep-matchp csts "request-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-rep-of-tree-fix-cst (equal (http-cst-start-line-conc1-rep (tree-fix cst)) (http-cst-start-line-conc1-rep cst)))
Theorem:
(defthm http-cst-start-line-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc1-rep cst) (http-cst-start-line-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)))) (let ((__function__ 'http-cst-start-line-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-start-line-conc2 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-start-line-conc2-rep (b* ((csts (http-cst-start-line-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-rep-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)) (b* ((csts (http-cst-start-line-conc2-rep cst))) (http-cst-list-rep-matchp csts "status-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-rep-of-tree-fix-cst (equal (http-cst-start-line-conc2-rep (tree-fix cst)) (http-cst-start-line-conc2-rep cst)))
Theorem:
(defthm http-cst-start-line-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc2-rep cst) (http-cst-start-line-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)))) (let ((__function__ 'http-cst-uri-host-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-uri-host-conc1 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-uri-host-conc1-rep (b* ((csts (http-cst-uri-host-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-rep-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)) (b* ((csts (http-cst-uri-host-conc1-rep cst))) (http-cst-list-rep-matchp csts "ip-literal"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-rep-of-tree-fix-cst (equal (http-cst-uri-host-conc1-rep (tree-fix cst)) (http-cst-uri-host-conc1-rep cst)))
Theorem:
(defthm http-cst-uri-host-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc1-rep cst) (http-cst-uri-host-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)))) (let ((__function__ 'http-cst-uri-host-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-uri-host-conc2 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-uri-host-conc2-rep (b* ((csts (http-cst-uri-host-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-rep-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)) (b* ((csts (http-cst-uri-host-conc2-rep cst))) (http-cst-list-rep-matchp csts "ipv4address"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-rep-of-tree-fix-cst (equal (http-cst-uri-host-conc2-rep (tree-fix cst)) (http-cst-uri-host-conc2-rep cst)))
Theorem:
(defthm http-cst-uri-host-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc2-rep cst) (http-cst-uri-host-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)))) (let ((__function__ 'http-cst-uri-host-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-uri-host-conc3 cst)))))
Theorem:
(defthm tree-listp-of-http-cst-uri-host-conc3-rep (b* ((csts (http-cst-uri-host-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-rep-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)) (b* ((csts (http-cst-uri-host-conc3-rep cst))) (http-cst-list-rep-matchp csts "reg-name"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-rep-of-tree-fix-cst (equal (http-cst-uri-host-conc3-rep (tree-fix cst)) (http-cst-uri-host-conc3-rep cst)))
Theorem:
(defthm http-cst-uri-host-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc3-rep cst) (http-cst-uri-host-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-cr-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "cr"))) (let ((__function__ 'http-cst-cr-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-cr-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-cr-conc-rep (b* ((csts (http-cst-cr-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-rep-match (implies (http-cst-matchp cst "cr") (b* ((csts (http-cst-cr-conc-rep cst))) (http-cst-list-rep-matchp csts "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-rep-of-tree-fix-cst (equal (http-cst-cr-conc-rep (tree-fix cst)) (http-cst-cr-conc-rep cst)))
Theorem:
(defthm http-cst-cr-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-cr-conc-rep cst) (http-cst-cr-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-digit-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "digit"))) (let ((__function__ 'http-cst-digit-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-digit-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-digit-conc-rep (b* ((csts (http-cst-digit-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-rep-match (implies (http-cst-matchp cst "digit") (b* ((csts (http-cst-digit-conc-rep cst))) (http-cst-list-rep-matchp csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-rep-of-tree-fix-cst (equal (http-cst-digit-conc-rep (tree-fix cst)) (http-cst-digit-conc-rep cst)))
Theorem:
(defthm http-cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-digit-conc-rep cst) (http-cst-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-dquote-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "dquote"))) (let ((__function__ 'http-cst-dquote-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-dquote-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-dquote-conc-rep (b* ((csts (http-cst-dquote-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-rep-match (implies (http-cst-matchp cst "dquote") (b* ((csts (http-cst-dquote-conc-rep cst))) (http-cst-list-rep-matchp csts "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-rep-of-tree-fix-cst (equal (http-cst-dquote-conc-rep (tree-fix cst)) (http-cst-dquote-conc-rep cst)))
Theorem:
(defthm http-cst-dquote-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-dquote-conc-rep cst) (http-cst-dquote-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-htab-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "htab"))) (let ((__function__ 'http-cst-htab-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-htab-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-htab-conc-rep (b* ((csts (http-cst-htab-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-rep-match (implies (http-cst-matchp cst "htab") (b* ((csts (http-cst-htab-conc-rep cst))) (http-cst-list-rep-matchp csts "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-rep-of-tree-fix-cst (equal (http-cst-htab-conc-rep (tree-fix cst)) (http-cst-htab-conc-rep cst)))
Theorem:
(defthm http-cst-htab-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-htab-conc-rep cst) (http-cst-htab-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-lf-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "lf"))) (let ((__function__ 'http-cst-lf-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-lf-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-lf-conc-rep (b* ((csts (http-cst-lf-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-rep-match (implies (http-cst-matchp cst "lf") (b* ((csts (http-cst-lf-conc-rep cst))) (http-cst-list-rep-matchp csts "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-rep-of-tree-fix-cst (equal (http-cst-lf-conc-rep (tree-fix cst)) (http-cst-lf-conc-rep cst)))
Theorem:
(defthm http-cst-lf-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-lf-conc-rep cst) (http-cst-lf-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-octet-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "octet"))) (let ((__function__ 'http-cst-octet-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-octet-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-octet-conc-rep (b* ((csts (http-cst-octet-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-rep-match (implies (http-cst-matchp cst "octet") (b* ((csts (http-cst-octet-conc-rep cst))) (http-cst-list-rep-matchp csts "%x0-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-rep-of-tree-fix-cst (equal (http-cst-octet-conc-rep (tree-fix cst)) (http-cst-octet-conc-rep cst)))
Theorem:
(defthm http-cst-octet-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-octet-conc-rep cst) (http-cst-octet-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-sp-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "sp"))) (let ((__function__ 'http-cst-sp-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-sp-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-sp-conc-rep (b* ((csts (http-cst-sp-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-rep-match (implies (http-cst-matchp cst "sp") (b* ((csts (http-cst-sp-conc-rep cst))) (http-cst-list-rep-matchp csts "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-rep-of-tree-fix-cst (equal (http-cst-sp-conc-rep (tree-fix cst)) (http-cst-sp-conc-rep cst)))
Theorem:
(defthm http-cst-sp-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-sp-conc-rep cst) (http-cst-sp-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-vchar-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "vchar"))) (let ((__function__ 'http-cst-vchar-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (http-cst-vchar-conc cst)))))
Theorem:
(defthm tree-listp-of-http-cst-vchar-conc-rep (b* ((csts (http-cst-vchar-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-rep-match (implies (http-cst-matchp cst "vchar") (b* ((csts (http-cst-vchar-conc-rep cst))) (http-cst-list-rep-matchp csts "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-rep-of-tree-fix-cst (equal (http-cst-vchar-conc-rep (tree-fix cst)) (http-cst-vchar-conc-rep cst)))
Theorem:
(defthm http-cst-vchar-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-vchar-conc-rep cst) (http-cst-vchar-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-bws-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "bws"))) (let ((__function__ 'http-cst-bws-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-bws-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-bws-conc-rep-elem (b* ((cst1 (http-cst-bws-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-rep-elem-match (implies (http-cst-matchp cst "bws") (b* ((cst1 (http-cst-bws-conc-rep-elem cst))) (http-cst-matchp cst1 "ows"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-bws-conc-rep-elem-of-tree-fix-cst (equal (http-cst-bws-conc-rep-elem (tree-fix cst)) (http-cst-bws-conc-rep-elem cst)))
Theorem:
(defthm http-cst-bws-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-bws-conc-rep-elem cst) (http-cst-bws-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-http-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "http-name"))) (let ((__function__ 'http-cst-http-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-http-name-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-http-name-conc-rep-elem (b* ((cst1 (http-cst-http-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-rep-elem-match (implies (http-cst-matchp cst "http-name") (b* ((cst1 (http-cst-http-name-conc-rep-elem cst))) (http-cst-matchp cst1 "%x48.54.54.50"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-http-name-conc-rep-elem-of-tree-fix-cst (equal (http-cst-http-name-conc-rep-elem (tree-fix cst)) (http-cst-http-name-conc-rep-elem cst)))
Theorem:
(defthm http-cst-http-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-http-name-conc-rep-elem cst) (http-cst-http-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-te-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "te"))) (let ((__function__ 'http-cst-te-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-te-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-te-conc-rep-elem (b* ((cst1 (http-cst-te-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-rep-elem-match (implies (http-cst-matchp cst "te") (b* ((cst1 (http-cst-te-conc-rep-elem cst))) (http-cst-matchp cst1 "[ ( \",\" / t-codings ) *( ows \",\" [ ows t-codings ] ) ]"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-te-conc-rep-elem-of-tree-fix-cst (equal (http-cst-te-conc-rep-elem (tree-fix cst)) (http-cst-te-conc-rep-elem cst)))
Theorem:
(defthm http-cst-te-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-te-conc-rep-elem cst) (http-cst-te-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-absolute-form-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "absolute-form"))) (let ((__function__ 'http-cst-absolute-form-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-absolute-form-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-absolute-form-conc-rep-elem (b* ((cst1 (http-cst-absolute-form-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-rep-elem-match (implies (http-cst-matchp cst "absolute-form") (b* ((cst1 (http-cst-absolute-form-conc-rep-elem cst))) (http-cst-matchp cst1 "absolute-uri"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-absolute-form-conc-rep-elem-of-tree-fix-cst (equal (http-cst-absolute-form-conc-rep-elem (tree-fix cst)) (http-cst-absolute-form-conc-rep-elem cst)))
Theorem:
(defthm http-cst-absolute-form-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-absolute-form-conc-rep-elem cst) (http-cst-absolute-form-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-asterisk-form-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "asterisk-form"))) (let ((__function__ 'http-cst-asterisk-form-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-asterisk-form-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-asterisk-form-conc-rep-elem (b* ((cst1 (http-cst-asterisk-form-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-rep-elem-match (implies (http-cst-matchp cst "asterisk-form") (b* ((cst1 (http-cst-asterisk-form-conc-rep-elem cst))) (http-cst-matchp cst1 "\"*\""))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-asterisk-form-conc-rep-elem-of-tree-fix-cst (equal (http-cst-asterisk-form-conc-rep-elem (tree-fix cst)) (http-cst-asterisk-form-conc-rep-elem cst)))
Theorem:
(defthm http-cst-asterisk-form-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-asterisk-form-conc-rep-elem cst) (http-cst-asterisk-form-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-authority-form-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "authority-form"))) (let ((__function__ 'http-cst-authority-form-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-authority-form-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-authority-form-conc-rep-elem (b* ((cst1 (http-cst-authority-form-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-rep-elem-match (implies (http-cst-matchp cst "authority-form") (b* ((cst1 (http-cst-authority-form-conc-rep-elem cst))) (http-cst-matchp cst1 "authority"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-authority-form-conc-rep-elem-of-tree-fix-cst (equal (http-cst-authority-form-conc-rep-elem (tree-fix cst)) (http-cst-authority-form-conc-rep-elem cst)))
Theorem:
(defthm http-cst-authority-form-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-authority-form-conc-rep-elem cst) (http-cst-authority-form-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "chunk-ext-name"))) (let ((__function__ 'http-cst-chunk-ext-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-chunk-ext-name-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-chunk-ext-name-conc-rep-elem (b* ((cst1 (http-cst-chunk-ext-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-elem-match (implies (http-cst-matchp cst "chunk-ext-name") (b* ((cst1 (http-cst-chunk-ext-name-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-elem-of-tree-fix-cst (equal (http-cst-chunk-ext-name-conc-rep-elem (tree-fix cst)) (http-cst-chunk-ext-name-conc-rep-elem cst)))
Theorem:
(defthm http-cst-chunk-ext-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-name-conc-rep-elem cst) (http-cst-chunk-ext-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)))) (let ((__function__ 'http-cst-chunk-ext-val-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-chunk-ext-val-conc1-rep cst)))))
Theorem:
(defthm treep-of-http-cst-chunk-ext-val-conc1-rep-elem (b* ((cst1 (http-cst-chunk-ext-val-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-elem-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 1)) (b* ((cst1 (http-cst-chunk-ext-val-conc1-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-elem-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc1-rep-elem (tree-fix cst)) (http-cst-chunk-ext-val-conc1-rep-elem cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc1-rep-elem cst) (http-cst-chunk-ext-val-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-chunk-ext-val-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)))) (let ((__function__ 'http-cst-chunk-ext-val-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-chunk-ext-val-conc2-rep cst)))))
Theorem:
(defthm treep-of-http-cst-chunk-ext-val-conc2-rep-elem (b* ((cst1 (http-cst-chunk-ext-val-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-elem-match (implies (and (http-cst-matchp cst "chunk-ext-val") (equal (http-cst-chunk-ext-val-conc? cst) 2)) (b* ((cst1 (http-cst-chunk-ext-val-conc2-rep-elem cst))) (http-cst-matchp cst1 "quoted-string"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-elem-of-tree-fix-cst (equal (http-cst-chunk-ext-val-conc2-rep-elem (tree-fix cst)) (http-cst-chunk-ext-val-conc2-rep-elem cst)))
Theorem:
(defthm http-cst-chunk-ext-val-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-chunk-ext-val-conc2-rep-elem cst) (http-cst-chunk-ext-val-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-connection-option-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "connection-option"))) (let ((__function__ 'http-cst-connection-option-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-connection-option-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-connection-option-conc-rep-elem (b* ((cst1 (http-cst-connection-option-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-rep-elem-match (implies (http-cst-matchp cst "connection-option") (b* ((cst1 (http-cst-connection-option-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-connection-option-conc-rep-elem-of-tree-fix-cst (equal (http-cst-connection-option-conc-rep-elem (tree-fix cst)) (http-cst-connection-option-conc-rep-elem cst)))
Theorem:
(defthm http-cst-connection-option-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-connection-option-conc-rep-elem cst) (http-cst-connection-option-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "field-name"))) (let ((__function__ 'http-cst-field-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-field-name-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-field-name-conc-rep-elem (b* ((cst1 (http-cst-field-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-rep-elem-match (implies (http-cst-matchp cst "field-name") (b* ((cst1 (http-cst-field-name-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-name-conc-rep-elem-of-tree-fix-cst (equal (http-cst-field-name-conc-rep-elem (tree-fix cst)) (http-cst-field-name-conc-rep-elem cst)))
Theorem:
(defthm http-cst-field-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-name-conc-rep-elem cst) (http-cst-field-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)))) (let ((__function__ 'http-cst-field-vchar-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-field-vchar-conc1-rep cst)))))
Theorem:
(defthm treep-of-http-cst-field-vchar-conc1-rep-elem (b* ((cst1 (http-cst-field-vchar-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-rep-elem-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 1)) (b* ((cst1 (http-cst-field-vchar-conc1-rep-elem cst))) (http-cst-matchp cst1 "vchar"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc1-rep-elem-of-tree-fix-cst (equal (http-cst-field-vchar-conc1-rep-elem (tree-fix cst)) (http-cst-field-vchar-conc1-rep-elem cst)))
Theorem:
(defthm http-cst-field-vchar-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc1-rep-elem cst) (http-cst-field-vchar-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-field-vchar-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)))) (let ((__function__ 'http-cst-field-vchar-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-field-vchar-conc2-rep cst)))))
Theorem:
(defthm treep-of-http-cst-field-vchar-conc2-rep-elem (b* ((cst1 (http-cst-field-vchar-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-rep-elem-match (implies (and (http-cst-matchp cst "field-vchar") (equal (http-cst-field-vchar-conc? cst) 2)) (b* ((cst1 (http-cst-field-vchar-conc2-rep-elem cst))) (http-cst-matchp cst1 "obs-text"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-field-vchar-conc2-rep-elem-of-tree-fix-cst (equal (http-cst-field-vchar-conc2-rep-elem (tree-fix cst)) (http-cst-field-vchar-conc2-rep-elem cst)))
Theorem:
(defthm http-cst-field-vchar-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-field-vchar-conc2-rep-elem cst) (http-cst-field-vchar-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-method-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "method"))) (let ((__function__ 'http-cst-method-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-method-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-method-conc-rep-elem (b* ((cst1 (http-cst-method-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-rep-elem-match (implies (http-cst-matchp cst "method") (b* ((cst1 (http-cst-method-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-method-conc-rep-elem-of-tree-fix-cst (equal (http-cst-method-conc-rep-elem (tree-fix cst)) (http-cst-method-conc-rep-elem cst)))
Theorem:
(defthm http-cst-method-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-method-conc-rep-elem cst) (http-cst-method-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-obs-text-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "obs-text"))) (let ((__function__ 'http-cst-obs-text-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-obs-text-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-obs-text-conc-rep-elem (b* ((cst1 (http-cst-obs-text-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-rep-elem-match (implies (http-cst-matchp cst "obs-text") (b* ((cst1 (http-cst-obs-text-conc-rep-elem cst))) (http-cst-matchp cst1 "%x80-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-obs-text-conc-rep-elem-of-tree-fix-cst (equal (http-cst-obs-text-conc-rep-elem (tree-fix cst)) (http-cst-obs-text-conc-rep-elem cst)))
Theorem:
(defthm http-cst-obs-text-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-obs-text-conc-rep-elem cst) (http-cst-obs-text-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-name-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-name"))) (let ((__function__ 'http-cst-protocol-name-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-protocol-name-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-protocol-name-conc-rep-elem (b* ((cst1 (http-cst-protocol-name-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-rep-elem-match (implies (http-cst-matchp cst "protocol-name") (b* ((cst1 (http-cst-protocol-name-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-name-conc-rep-elem-of-tree-fix-cst (equal (http-cst-protocol-name-conc-rep-elem (tree-fix cst)) (http-cst-protocol-name-conc-rep-elem cst)))
Theorem:
(defthm http-cst-protocol-name-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-name-conc-rep-elem cst) (http-cst-protocol-name-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-protocol-version-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "protocol-version"))) (let ((__function__ 'http-cst-protocol-version-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-protocol-version-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-protocol-version-conc-rep-elem (b* ((cst1 (http-cst-protocol-version-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-rep-elem-match (implies (http-cst-matchp cst "protocol-version") (b* ((cst1 (http-cst-protocol-version-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-protocol-version-conc-rep-elem-of-tree-fix-cst (equal (http-cst-protocol-version-conc-rep-elem (tree-fix cst)) (http-cst-protocol-version-conc-rep-elem cst)))
Theorem:
(defthm http-cst-protocol-version-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-protocol-version-conc-rep-elem cst) (http-cst-protocol-version-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-pseudonym-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "pseudonym"))) (let ((__function__ 'http-cst-pseudonym-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-pseudonym-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-pseudonym-conc-rep-elem (b* ((cst1 (http-cst-pseudonym-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-rep-elem-match (implies (http-cst-matchp cst "pseudonym") (b* ((cst1 (http-cst-pseudonym-conc-rep-elem cst))) (http-cst-matchp cst1 "token"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-pseudonym-conc-rep-elem-of-tree-fix-cst (equal (http-cst-pseudonym-conc-rep-elem (tree-fix cst)) (http-cst-pseudonym-conc-rep-elem cst)))
Theorem:
(defthm http-cst-pseudonym-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-pseudonym-conc-rep-elem cst) (http-cst-pseudonym-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)))) (let ((__function__ 'http-cst-request-target-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-request-target-conc1-rep cst)))))
Theorem:
(defthm treep-of-http-cst-request-target-conc1-rep-elem (b* ((cst1 (http-cst-request-target-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-rep-elem-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 1)) (b* ((cst1 (http-cst-request-target-conc1-rep-elem cst))) (http-cst-matchp cst1 "origin-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc1-rep-elem-of-tree-fix-cst (equal (http-cst-request-target-conc1-rep-elem (tree-fix cst)) (http-cst-request-target-conc1-rep-elem cst)))
Theorem:
(defthm http-cst-request-target-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc1-rep-elem cst) (http-cst-request-target-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)))) (let ((__function__ 'http-cst-request-target-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-request-target-conc2-rep cst)))))
Theorem:
(defthm treep-of-http-cst-request-target-conc2-rep-elem (b* ((cst1 (http-cst-request-target-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-rep-elem-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 2)) (b* ((cst1 (http-cst-request-target-conc2-rep-elem cst))) (http-cst-matchp cst1 "absolute-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc2-rep-elem-of-tree-fix-cst (equal (http-cst-request-target-conc2-rep-elem (tree-fix cst)) (http-cst-request-target-conc2-rep-elem cst)))
Theorem:
(defthm http-cst-request-target-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc2-rep-elem cst) (http-cst-request-target-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)))) (let ((__function__ 'http-cst-request-target-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-request-target-conc3-rep cst)))))
Theorem:
(defthm treep-of-http-cst-request-target-conc3-rep-elem (b* ((cst1 (http-cst-request-target-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-rep-elem-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 3)) (b* ((cst1 (http-cst-request-target-conc3-rep-elem cst))) (http-cst-matchp cst1 "authority-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc3-rep-elem-of-tree-fix-cst (equal (http-cst-request-target-conc3-rep-elem (tree-fix cst)) (http-cst-request-target-conc3-rep-elem cst)))
Theorem:
(defthm http-cst-request-target-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc3-rep-elem cst) (http-cst-request-target-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-request-target-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)))) (let ((__function__ 'http-cst-request-target-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-request-target-conc4-rep cst)))))
Theorem:
(defthm treep-of-http-cst-request-target-conc4-rep-elem (b* ((cst1 (http-cst-request-target-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-rep-elem-match (implies (and (http-cst-matchp cst "request-target") (equal (http-cst-request-target-conc? cst) 4)) (b* ((cst1 (http-cst-request-target-conc4-rep-elem cst))) (http-cst-matchp cst1 "asterisk-form"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-request-target-conc4-rep-elem-of-tree-fix-cst (equal (http-cst-request-target-conc4-rep-elem (tree-fix cst)) (http-cst-request-target-conc4-rep-elem cst)))
Theorem:
(defthm http-cst-request-target-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-request-target-conc4-rep-elem cst) (http-cst-request-target-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)))) (let ((__function__ 'http-cst-start-line-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-start-line-conc1-rep cst)))))
Theorem:
(defthm treep-of-http-cst-start-line-conc1-rep-elem (b* ((cst1 (http-cst-start-line-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-rep-elem-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 1)) (b* ((cst1 (http-cst-start-line-conc1-rep-elem cst))) (http-cst-matchp cst1 "request-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc1-rep-elem-of-tree-fix-cst (equal (http-cst-start-line-conc1-rep-elem (tree-fix cst)) (http-cst-start-line-conc1-rep-elem cst)))
Theorem:
(defthm http-cst-start-line-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc1-rep-elem cst) (http-cst-start-line-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-start-line-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)))) (let ((__function__ 'http-cst-start-line-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-start-line-conc2-rep cst)))))
Theorem:
(defthm treep-of-http-cst-start-line-conc2-rep-elem (b* ((cst1 (http-cst-start-line-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-rep-elem-match (implies (and (http-cst-matchp cst "start-line") (equal (http-cst-start-line-conc? cst) 2)) (b* ((cst1 (http-cst-start-line-conc2-rep-elem cst))) (http-cst-matchp cst1 "status-line"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-start-line-conc2-rep-elem-of-tree-fix-cst (equal (http-cst-start-line-conc2-rep-elem (tree-fix cst)) (http-cst-start-line-conc2-rep-elem cst)))
Theorem:
(defthm http-cst-start-line-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-start-line-conc2-rep-elem cst) (http-cst-start-line-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)))) (let ((__function__ 'http-cst-uri-host-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-uri-host-conc1-rep cst)))))
Theorem:
(defthm treep-of-http-cst-uri-host-conc1-rep-elem (b* ((cst1 (http-cst-uri-host-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-rep-elem-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 1)) (b* ((cst1 (http-cst-uri-host-conc1-rep-elem cst))) (http-cst-matchp cst1 "ip-literal"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc1-rep-elem-of-tree-fix-cst (equal (http-cst-uri-host-conc1-rep-elem (tree-fix cst)) (http-cst-uri-host-conc1-rep-elem cst)))
Theorem:
(defthm http-cst-uri-host-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc1-rep-elem cst) (http-cst-uri-host-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)))) (let ((__function__ 'http-cst-uri-host-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-uri-host-conc2-rep cst)))))
Theorem:
(defthm treep-of-http-cst-uri-host-conc2-rep-elem (b* ((cst1 (http-cst-uri-host-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-rep-elem-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 2)) (b* ((cst1 (http-cst-uri-host-conc2-rep-elem cst))) (http-cst-matchp cst1 "ipv4address"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc2-rep-elem-of-tree-fix-cst (equal (http-cst-uri-host-conc2-rep-elem (tree-fix cst)) (http-cst-uri-host-conc2-rep-elem cst)))
Theorem:
(defthm http-cst-uri-host-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc2-rep-elem cst) (http-cst-uri-host-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-uri-host-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)))) (let ((__function__ 'http-cst-uri-host-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-uri-host-conc3-rep cst)))))
Theorem:
(defthm treep-of-http-cst-uri-host-conc3-rep-elem (b* ((cst1 (http-cst-uri-host-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-rep-elem-match (implies (and (http-cst-matchp cst "uri-host") (equal (http-cst-uri-host-conc? cst) 3)) (b* ((cst1 (http-cst-uri-host-conc3-rep-elem cst))) (http-cst-matchp cst1 "reg-name"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-uri-host-conc3-rep-elem-of-tree-fix-cst (equal (http-cst-uri-host-conc3-rep-elem (tree-fix cst)) (http-cst-uri-host-conc3-rep-elem cst)))
Theorem:
(defthm http-cst-uri-host-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-uri-host-conc3-rep-elem cst) (http-cst-uri-host-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-cr-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "cr"))) (let ((__function__ 'http-cst-cr-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-cr-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-cr-conc-rep-elem (b* ((cst1 (http-cst-cr-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-rep-elem-match (implies (http-cst-matchp cst "cr") (b* ((cst1 (http-cst-cr-conc-rep-elem cst))) (http-cst-matchp cst1 "%xD"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-cr-conc-rep-elem-of-tree-fix-cst (equal (http-cst-cr-conc-rep-elem (tree-fix cst)) (http-cst-cr-conc-rep-elem cst)))
Theorem:
(defthm http-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-cr-conc-rep-elem cst) (http-cst-cr-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-digit-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "digit"))) (let ((__function__ 'http-cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-digit-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-digit-conc-rep-elem (b* ((cst1 (http-cst-digit-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-rep-elem-match (implies (http-cst-matchp cst "digit") (b* ((cst1 (http-cst-digit-conc-rep-elem cst))) (http-cst-matchp cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-digit-conc-rep-elem-of-tree-fix-cst (equal (http-cst-digit-conc-rep-elem (tree-fix cst)) (http-cst-digit-conc-rep-elem cst)))
Theorem:
(defthm http-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-digit-conc-rep-elem cst) (http-cst-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-dquote-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "dquote"))) (let ((__function__ 'http-cst-dquote-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-dquote-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-dquote-conc-rep-elem (b* ((cst1 (http-cst-dquote-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-rep-elem-match (implies (http-cst-matchp cst "dquote") (b* ((cst1 (http-cst-dquote-conc-rep-elem cst))) (http-cst-matchp cst1 "%x22"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-dquote-conc-rep-elem-of-tree-fix-cst (equal (http-cst-dquote-conc-rep-elem (tree-fix cst)) (http-cst-dquote-conc-rep-elem cst)))
Theorem:
(defthm http-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-dquote-conc-rep-elem cst) (http-cst-dquote-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-htab-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "htab"))) (let ((__function__ 'http-cst-htab-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-htab-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-htab-conc-rep-elem (b* ((cst1 (http-cst-htab-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-rep-elem-match (implies (http-cst-matchp cst "htab") (b* ((cst1 (http-cst-htab-conc-rep-elem cst))) (http-cst-matchp cst1 "%x9"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-htab-conc-rep-elem-of-tree-fix-cst (equal (http-cst-htab-conc-rep-elem (tree-fix cst)) (http-cst-htab-conc-rep-elem cst)))
Theorem:
(defthm http-cst-htab-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-htab-conc-rep-elem cst) (http-cst-htab-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-lf-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "lf"))) (let ((__function__ 'http-cst-lf-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-lf-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-lf-conc-rep-elem (b* ((cst1 (http-cst-lf-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-rep-elem-match (implies (http-cst-matchp cst "lf") (b* ((cst1 (http-cst-lf-conc-rep-elem cst))) (http-cst-matchp cst1 "%xA"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-lf-conc-rep-elem-of-tree-fix-cst (equal (http-cst-lf-conc-rep-elem (tree-fix cst)) (http-cst-lf-conc-rep-elem cst)))
Theorem:
(defthm http-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-lf-conc-rep-elem cst) (http-cst-lf-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-octet-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "octet"))) (let ((__function__ 'http-cst-octet-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-octet-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-octet-conc-rep-elem (b* ((cst1 (http-cst-octet-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-rep-elem-match (implies (http-cst-matchp cst "octet") (b* ((cst1 (http-cst-octet-conc-rep-elem cst))) (http-cst-matchp cst1 "%x0-FF"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-octet-conc-rep-elem-of-tree-fix-cst (equal (http-cst-octet-conc-rep-elem (tree-fix cst)) (http-cst-octet-conc-rep-elem cst)))
Theorem:
(defthm http-cst-octet-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-octet-conc-rep-elem cst) (http-cst-octet-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-sp-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "sp"))) (let ((__function__ 'http-cst-sp-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-sp-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-sp-conc-rep-elem (b* ((cst1 (http-cst-sp-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-rep-elem-match (implies (http-cst-matchp cst "sp") (b* ((cst1 (http-cst-sp-conc-rep-elem cst))) (http-cst-matchp cst1 "%x20"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-sp-conc-rep-elem-of-tree-fix-cst (equal (http-cst-sp-conc-rep-elem (tree-fix cst)) (http-cst-sp-conc-rep-elem cst)))
Theorem:
(defthm http-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-sp-conc-rep-elem cst) (http-cst-sp-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun http-cst-vchar-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (http-cst-matchp cst "vchar"))) (let ((__function__ 'http-cst-vchar-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (http-cst-vchar-conc-rep cst)))))
Theorem:
(defthm treep-of-http-cst-vchar-conc-rep-elem (b* ((cst1 (http-cst-vchar-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-rep-elem-match (implies (http-cst-matchp cst "vchar") (b* ((cst1 (http-cst-vchar-conc-rep-elem cst))) (http-cst-matchp cst1 "%x21-7E"))) :rule-classes :rewrite)
Theorem:
(defthm http-cst-vchar-conc-rep-elem-of-tree-fix-cst (equal (http-cst-vchar-conc-rep-elem (tree-fix cst)) (http-cst-vchar-conc-rep-elem cst)))
Theorem:
(defthm http-cst-vchar-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (http-cst-vchar-conc-rep-elem cst) (http-cst-vchar-conc-rep-elem cst-equiv))) :rule-classes :congruence)