Tree operations specialized to *pdf-grammar-rules*.
Function:
(defun pdf-cst-matchp$ (tree elem) (declare (xargs :guard (and (treep tree) (elementp elem)))) (let ((__function__ 'pdf-cst-matchp$)) (declare (ignorable __function__)) (and (tree-terminatedp tree) (tree-match-element-p tree elem *pdf-grammar-rules*))))
Theorem:
(defthm booleanp-of-pdf-cst-matchp$ (b* ((yes/no (pdf-cst-matchp$ tree elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-matchp$-of-tree-fix-tree (equal (pdf-cst-matchp$ (tree-fix tree) elem) (pdf-cst-matchp$ tree elem)))
Theorem:
(defthm pdf-cst-matchp$-tree-equiv-congruence-on-tree (implies (tree-equiv tree tree-equiv) (equal (pdf-cst-matchp$ tree elem) (pdf-cst-matchp$ tree-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-matchp$-of-element-fix-elem (equal (pdf-cst-matchp$ tree (element-fix elem)) (pdf-cst-matchp$ tree elem)))
Theorem:
(defthm pdf-cst-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (pdf-cst-matchp$ tree elem) (pdf-cst-matchp$ tree elem-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-list-elem-matchp$ (trees elem) (declare (xargs :guard (and (tree-listp trees) (elementp elem)))) (let ((__function__ 'pdf-cst-list-elem-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-element-p trees elem *pdf-grammar-rules*))))
Theorem:
(defthm booleanp-of-pdf-cst-list-elem-matchp$ (b* ((yes/no (pdf-cst-list-elem-matchp$ trees elem))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-list-elem-matchp$-of-tree-list-fix-trees (equal (pdf-cst-list-elem-matchp$ (tree-list-fix trees) elem) (pdf-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm pdf-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (pdf-cst-list-elem-matchp$ trees elem) (pdf-cst-list-elem-matchp$ trees-equiv elem))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-list-elem-matchp$-of-element-fix-elem (equal (pdf-cst-list-elem-matchp$ trees (element-fix elem)) (pdf-cst-list-elem-matchp$ trees elem)))
Theorem:
(defthm pdf-cst-list-elem-matchp$-element-equiv-congruence-on-elem (implies (element-equiv elem elem-equiv) (equal (pdf-cst-list-elem-matchp$ trees elem) (pdf-cst-list-elem-matchp$ trees elem-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-list-rep-matchp$ (trees rep) (declare (xargs :guard (and (tree-listp trees) (repetitionp rep)))) (let ((__function__ 'pdf-cst-list-rep-matchp$)) (declare (ignorable __function__)) (and (tree-list-terminatedp trees) (tree-list-match-repetition-p trees rep *pdf-grammar-rules*))))
Theorem:
(defthm booleanp-of-pdf-cst-list-rep-matchp$ (b* ((yes/no (pdf-cst-list-rep-matchp$ trees rep))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-list-rep-matchp$-of-tree-list-fix-trees (equal (pdf-cst-list-rep-matchp$ (tree-list-fix trees) rep) (pdf-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm pdf-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees (implies (tree-list-equiv trees trees-equiv) (equal (pdf-cst-list-rep-matchp$ trees rep) (pdf-cst-list-rep-matchp$ trees-equiv rep))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-list-rep-matchp$-of-repetition-fix-rep (equal (pdf-cst-list-rep-matchp$ trees (repetition-fix rep)) (pdf-cst-list-rep-matchp$ trees rep)))
Theorem:
(defthm pdf-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep (implies (repetition-equiv rep rep-equiv) (equal (pdf-cst-list-rep-matchp$ trees rep) (pdf-cst-list-rep-matchp$ trees rep-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-list-list-conc-matchp$ (treess conc) (declare (xargs :guard (and (tree-list-listp treess) (concatenationp conc)))) (let ((__function__ 'pdf-cst-list-list-conc-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-concatenation-p treess conc *pdf-grammar-rules*))))
Theorem:
(defthm booleanp-of-pdf-cst-list-list-conc-matchp$ (b* ((yes/no (pdf-cst-list-list-conc-matchp$ treess conc))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess (equal (pdf-cst-list-list-conc-matchp$ (tree-list-list-fix treess) conc) (pdf-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm pdf-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (pdf-cst-list-list-conc-matchp$ treess conc) (pdf-cst-list-list-conc-matchp$ treess-equiv conc))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-list-list-conc-matchp$-of-concatenation-fix-conc (equal (pdf-cst-list-list-conc-matchp$ treess (concatenation-fix conc)) (pdf-cst-list-list-conc-matchp$ treess conc)))
Theorem:
(defthm pdf-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc (implies (concatenation-equiv conc conc-equiv) (equal (pdf-cst-list-list-conc-matchp$ treess conc) (pdf-cst-list-list-conc-matchp$ treess conc-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-list-list-alt-matchp$ (treess alt) (declare (xargs :guard (and (tree-list-listp treess) (alternationp alt)))) (let ((__function__ 'pdf-cst-list-list-alt-matchp$)) (declare (ignorable __function__)) (and (tree-list-list-terminatedp treess) (tree-list-list-match-alternation-p treess alt *pdf-grammar-rules*))))
Theorem:
(defthm booleanp-of-pdf-cst-list-list-alt-matchp$ (b* ((yes/no (pdf-cst-list-list-alt-matchp$ treess alt))) (booleanp yes/no)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess (equal (pdf-cst-list-list-alt-matchp$ (tree-list-list-fix treess) alt) (pdf-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm pdf-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess (implies (tree-list-list-equiv treess treess-equiv) (equal (pdf-cst-list-list-alt-matchp$ treess alt) (pdf-cst-list-list-alt-matchp$ treess-equiv alt))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-list-list-alt-matchp$-of-alternation-fix-alt (equal (pdf-cst-list-list-alt-matchp$ treess (alternation-fix alt)) (pdf-cst-list-list-alt-matchp$ treess alt)))
Theorem:
(defthm pdf-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt (implies (alternation-equiv alt alt-equiv) (equal (pdf-cst-list-list-alt-matchp$ treess alt) (pdf-cst-list-list-alt-matchp$ treess alt-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x20-21-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x20-21"))) (let ((__function__ 'pdf-cst-%x20-21-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x20-21-nat (b* ((nat (pdf-cst-%x20-21-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x20-21-nat-of-tree-fix-cst (equal (pdf-cst-%x20-21-nat (tree-fix cst)) (pdf-cst-%x20-21-nat cst)))
Theorem:
(defthm pdf-cst-%x20-21-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x20-21-nat cst) (pdf-cst-%x20-21-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x20-7e-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x20-7E"))) (let ((__function__ 'pdf-cst-%x20-7e-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x20-7e-nat (b* ((nat (pdf-cst-%x20-7e-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x20-7e-nat-of-tree-fix-cst (equal (pdf-cst-%x20-7e-nat (tree-fix cst)) (pdf-cst-%x20-7e-nat cst)))
Theorem:
(defthm pdf-cst-%x20-7e-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x20-7e-nat cst) (pdf-cst-%x20-7e-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x23-5b-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x23-5B"))) (let ((__function__ 'pdf-cst-%x23-5b-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x23-5b-nat (b* ((nat (pdf-cst-%x23-5b-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x23-5b-nat-of-tree-fix-cst (equal (pdf-cst-%x23-5b-nat (tree-fix cst)) (pdf-cst-%x23-5b-nat cst)))
Theorem:
(defthm pdf-cst-%x23-5b-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x23-5b-nat cst) (pdf-cst-%x23-5b-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x30-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x30-39"))) (let ((__function__ 'pdf-cst-%x30-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x30-39-nat (b* ((nat (pdf-cst-%x30-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x30-39-nat-of-tree-fix-cst (equal (pdf-cst-%x30-39-nat (tree-fix cst)) (pdf-cst-%x30-39-nat cst)))
Theorem:
(defthm pdf-cst-%x30-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x30-39-nat cst) (pdf-cst-%x30-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x31-39-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x31-39"))) (let ((__function__ 'pdf-cst-%x31-39-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x31-39-nat (b* ((nat (pdf-cst-%x31-39-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x31-39-nat-of-tree-fix-cst (equal (pdf-cst-%x31-39-nat (tree-fix cst)) (pdf-cst-%x31-39-nat cst)))
Theorem:
(defthm pdf-cst-%x31-39-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x31-39-nat cst) (pdf-cst-%x31-39-nat cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-%x5d-10ffff-nat (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "%x5D-10FFFF"))) (let ((__function__ 'pdf-cst-%x5d-10ffff-nat)) (declare (ignorable __function__)) (lnfix (nth 0 (tree-leafterm->get cst)))))
Theorem:
(defthm natp-of-pdf-cst-%x5d-10ffff-nat (b* ((nat (pdf-cst-%x5d-10ffff-nat cst))) (natp nat)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-%x5d-10ffff-nat-of-tree-fix-cst (equal (pdf-cst-%x5d-10ffff-nat (tree-fix cst)) (pdf-cst-%x5d-10ffff-nat cst)))
Theorem:
(defthm pdf-cst-%x5d-10ffff-nat-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-%x5d-10ffff-nat cst) (pdf-cst-%x5d-10ffff-nat cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-%x20-21-nat-bounds (implies (pdf-cst-matchp cst "%x20-21") (and (<= 32 (pdf-cst-%x20-21-nat cst)) (<= (pdf-cst-%x20-21-nat cst) 33))) :rule-classes :linear)
Theorem:
(defthm pdf-cst-%x20-7e-nat-bounds (implies (pdf-cst-matchp cst "%x20-7E") (and (<= 32 (pdf-cst-%x20-7e-nat cst)) (<= (pdf-cst-%x20-7e-nat cst) 126))) :rule-classes :linear)
Theorem:
(defthm pdf-cst-%x23-5b-nat-bounds (implies (pdf-cst-matchp cst "%x23-5B") (and (<= 35 (pdf-cst-%x23-5b-nat cst)) (<= (pdf-cst-%x23-5b-nat cst) 91))) :rule-classes :linear)
Theorem:
(defthm pdf-cst-%x30-39-nat-bounds (implies (pdf-cst-matchp cst "%x30-39") (and (<= 48 (pdf-cst-%x30-39-nat cst)) (<= (pdf-cst-%x30-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm pdf-cst-%x31-39-nat-bounds (implies (pdf-cst-matchp cst "%x31-39") (and (<= 49 (pdf-cst-%x31-39-nat cst)) (<= (pdf-cst-%x31-39-nat cst) 57))) :rule-classes :linear)
Theorem:
(defthm pdf-cst-%x5d-10ffff-nat-bounds (implies (pdf-cst-matchp cst "%x5D-10FFFF") (and (<= 93 (pdf-cst-%x5d-10ffff-nat cst)) (<= (pdf-cst-%x5d-10ffff-nat cst) 1114111))) :rule-classes :linear)
Theorem:
(defthm |PDF-CST-%s"/BaseFont"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/BaseFont\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Contents"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Contents\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Count"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Count\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Encoding"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Encoding\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Font"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Font\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/ID"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/ID\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Info"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Info\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Kids"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Kids\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Length"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Length\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/MediaBox"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/MediaBox\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Pages"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Pages\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Parent"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Parent\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Resources"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Resources\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Root"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Root\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Size"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Size\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Subtype"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Subtype\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"/Type"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"/Type\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"CropBox"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"CropBox\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"false"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"false\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"null"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"null\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm |PDF-CST-%s"true"-LEAFTERM| (implies (pdf-cst-matchp cst "%s\"true\"") (equal (tree-kind cst) :leafterm)))
Theorem:
(defthm pdf-cst-pdf-nonleaf (implies (pdf-cst-matchp cst "pdf") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-header-nonleaf (implies (pdf-cst-matchp cst "header") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-pdf-marker-nonleaf (implies (pdf-cst-matchp cst "pdf-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-objects-nonleaf (implies (pdf-cst-matchp cst "objects") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-object-nonleaf (implies (pdf-cst-matchp cst "object") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-obj-marker-nonleaf (implies (pdf-cst-matchp cst "obj-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-endobj-marker-nonleaf (implies (pdf-cst-matchp cst "endobj-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-stream-nonleaf (implies (pdf-cst-matchp cst "stream") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-stream-marker-nonleaf (implies (pdf-cst-matchp cst "stream-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-endstream-marker-nonleaf (implies (pdf-cst-matchp cst "endstream-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-xref-nonleaf (implies (pdf-cst-matchp cst "xref") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-xref-entry-nonleaf (implies (pdf-cst-matchp cst "xref-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-use-marker-nonleaf (implies (pdf-cst-matchp cst "use-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-xref-marker-nonleaf (implies (pdf-cst-matchp cst "xref-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-xref-int-nonleaf (implies (pdf-cst-matchp cst "xref-int") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-trailer-nonleaf (implies (pdf-cst-matchp cst "trailer") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-startxref-marker-nonleaf (implies (pdf-cst-matchp cst "startxref-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-eof-marker-nonleaf (implies (pdf-cst-matchp cst "eof-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-trailer-dictionary-nonleaf (implies (pdf-cst-matchp cst "trailer-dictionary") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-trailer-key-and-value-nonleaf (implies (pdf-cst-matchp cst "trailer-key-and-value") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-trailer-marker-nonleaf (implies (pdf-cst-matchp cst "trailer-marker") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-dictionary-nonleaf (implies (pdf-cst-matchp cst "dictionary") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-dict-entry-nonleaf (implies (pdf-cst-matchp cst "dict-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-default-entry-nonleaf (implies (pdf-cst-matchp cst "default-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-type-entry-nonleaf (implies (pdf-cst-matchp cst "type-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-reference-entry-nonleaf (implies (pdf-cst-matchp cst "reference-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-reference-array-entry-nonleaf (implies (pdf-cst-matchp cst "reference-array-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-rectangle-entry-nonleaf (implies (pdf-cst-matchp cst "rectangle-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-number-entry-nonleaf (implies (pdf-cst-matchp cst "number-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-name-entry-nonleaf (implies (pdf-cst-matchp cst "name-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-font-entry-nonleaf (implies (pdf-cst-matchp cst "font-entry") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-font-nonleaf (implies (pdf-cst-matchp cst "font") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-dict-key-nonleaf (implies (pdf-cst-matchp cst "dict-key") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-dict-value-nonleaf (implies (pdf-cst-matchp cst "dict-value") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-start-dict-nonleaf (implies (pdf-cst-matchp cst "start-dict") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-end-dict-nonleaf (implies (pdf-cst-matchp cst "end-dict") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-ws-nonleaf (implies (pdf-cst-matchp cst "ws") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-digit1-9-nonleaf (implies (pdf-cst-matchp cst "digit1-9") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-digit-nonleaf (implies (pdf-cst-matchp cst "digit") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-boolean-nonleaf (implies (pdf-cst-matchp cst "boolean") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-array-nonleaf (implies (pdf-cst-matchp cst "array") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-reference-array-nonleaf (implies (pdf-cst-matchp cst "reference-array") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-reference-nonleaf (implies (pdf-cst-matchp cst "reference") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-rectangle-nonleaf (implies (pdf-cst-matchp cst "rectangle") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-left-bracket-nonleaf (implies (pdf-cst-matchp cst "left-bracket") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-right-bracket-nonleaf (implies (pdf-cst-matchp cst "right-bracket") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-number-nonleaf (implies (pdf-cst-matchp cst "number") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-null-nonleaf (implies (pdf-cst-matchp cst "null") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-name-nonleaf (implies (pdf-cst-matchp cst "name") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-name-char-nonleaf (implies (pdf-cst-matchp cst "name-char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-real-nonleaf (implies (pdf-cst-matchp cst "real") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-int-nonleaf (implies (pdf-cst-matchp cst "int") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-plus-nonleaf (implies (pdf-cst-matchp cst "plus") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-minus-nonleaf (implies (pdf-cst-matchp cst "minus") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-slash-nonleaf (implies (pdf-cst-matchp cst "slash") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-backslash-nonleaf (implies (pdf-cst-matchp cst "backslash") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-zero-nonleaf (implies (pdf-cst-matchp cst "zero") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-string-nonleaf (implies (pdf-cst-matchp cst "string") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-period-nonleaf (implies (pdf-cst-matchp cst "period") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-char-nonleaf (implies (pdf-cst-matchp cst "char") (equal (tree-kind cst) :nonleaf)))
Theorem:
(defthm pdf-cst-pdf-rulename (implies (pdf-cst-matchp cst "pdf") (equal (tree-nonleaf->rulename? cst) (rulename "pdf"))))
Theorem:
(defthm pdf-cst-header-rulename (implies (pdf-cst-matchp cst "header") (equal (tree-nonleaf->rulename? cst) (rulename "header"))))
Theorem:
(defthm pdf-cst-pdf-marker-rulename (implies (pdf-cst-matchp cst "pdf-marker") (equal (tree-nonleaf->rulename? cst) (rulename "pdf-marker"))))
Theorem:
(defthm pdf-cst-objects-rulename (implies (pdf-cst-matchp cst "objects") (equal (tree-nonleaf->rulename? cst) (rulename "objects"))))
Theorem:
(defthm pdf-cst-object-rulename (implies (pdf-cst-matchp cst "object") (equal (tree-nonleaf->rulename? cst) (rulename "object"))))
Theorem:
(defthm pdf-cst-obj-marker-rulename (implies (pdf-cst-matchp cst "obj-marker") (equal (tree-nonleaf->rulename? cst) (rulename "obj-marker"))))
Theorem:
(defthm pdf-cst-endobj-marker-rulename (implies (pdf-cst-matchp cst "endobj-marker") (equal (tree-nonleaf->rulename? cst) (rulename "endobj-marker"))))
Theorem:
(defthm pdf-cst-stream-rulename (implies (pdf-cst-matchp cst "stream") (equal (tree-nonleaf->rulename? cst) (rulename "stream"))))
Theorem:
(defthm pdf-cst-stream-marker-rulename (implies (pdf-cst-matchp cst "stream-marker") (equal (tree-nonleaf->rulename? cst) (rulename "stream-marker"))))
Theorem:
(defthm pdf-cst-endstream-marker-rulename (implies (pdf-cst-matchp cst "endstream-marker") (equal (tree-nonleaf->rulename? cst) (rulename "endstream-marker"))))
Theorem:
(defthm pdf-cst-xref-rulename (implies (pdf-cst-matchp cst "xref") (equal (tree-nonleaf->rulename? cst) (rulename "xref"))))
Theorem:
(defthm pdf-cst-xref-entry-rulename (implies (pdf-cst-matchp cst "xref-entry") (equal (tree-nonleaf->rulename? cst) (rulename "xref-entry"))))
Theorem:
(defthm pdf-cst-use-marker-rulename (implies (pdf-cst-matchp cst "use-marker") (equal (tree-nonleaf->rulename? cst) (rulename "use-marker"))))
Theorem:
(defthm pdf-cst-xref-marker-rulename (implies (pdf-cst-matchp cst "xref-marker") (equal (tree-nonleaf->rulename? cst) (rulename "xref-marker"))))
Theorem:
(defthm pdf-cst-xref-int-rulename (implies (pdf-cst-matchp cst "xref-int") (equal (tree-nonleaf->rulename? cst) (rulename "xref-int"))))
Theorem:
(defthm pdf-cst-trailer-rulename (implies (pdf-cst-matchp cst "trailer") (equal (tree-nonleaf->rulename? cst) (rulename "trailer"))))
Theorem:
(defthm pdf-cst-startxref-marker-rulename (implies (pdf-cst-matchp cst "startxref-marker") (equal (tree-nonleaf->rulename? cst) (rulename "startxref-marker"))))
Theorem:
(defthm pdf-cst-eof-marker-rulename (implies (pdf-cst-matchp cst "eof-marker") (equal (tree-nonleaf->rulename? cst) (rulename "eof-marker"))))
Theorem:
(defthm pdf-cst-trailer-dictionary-rulename (implies (pdf-cst-matchp cst "trailer-dictionary") (equal (tree-nonleaf->rulename? cst) (rulename "trailer-dictionary"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-rulename (implies (pdf-cst-matchp cst "trailer-key-and-value") (equal (tree-nonleaf->rulename? cst) (rulename "trailer-key-and-value"))))
Theorem:
(defthm pdf-cst-trailer-marker-rulename (implies (pdf-cst-matchp cst "trailer-marker") (equal (tree-nonleaf->rulename? cst) (rulename "trailer-marker"))))
Theorem:
(defthm pdf-cst-dictionary-rulename (implies (pdf-cst-matchp cst "dictionary") (equal (tree-nonleaf->rulename? cst) (rulename "dictionary"))))
Theorem:
(defthm pdf-cst-dict-entry-rulename (implies (pdf-cst-matchp cst "dict-entry") (equal (tree-nonleaf->rulename? cst) (rulename "dict-entry"))))
Theorem:
(defthm pdf-cst-default-entry-rulename (implies (pdf-cst-matchp cst "default-entry") (equal (tree-nonleaf->rulename? cst) (rulename "default-entry"))))
Theorem:
(defthm pdf-cst-type-entry-rulename (implies (pdf-cst-matchp cst "type-entry") (equal (tree-nonleaf->rulename? cst) (rulename "type-entry"))))
Theorem:
(defthm pdf-cst-reference-entry-rulename (implies (pdf-cst-matchp cst "reference-entry") (equal (tree-nonleaf->rulename? cst) (rulename "reference-entry"))))
Theorem:
(defthm pdf-cst-reference-array-entry-rulename (implies (pdf-cst-matchp cst "reference-array-entry") (equal (tree-nonleaf->rulename? cst) (rulename "reference-array-entry"))))
Theorem:
(defthm pdf-cst-rectangle-entry-rulename (implies (pdf-cst-matchp cst "rectangle-entry") (equal (tree-nonleaf->rulename? cst) (rulename "rectangle-entry"))))
Theorem:
(defthm pdf-cst-number-entry-rulename (implies (pdf-cst-matchp cst "number-entry") (equal (tree-nonleaf->rulename? cst) (rulename "number-entry"))))
Theorem:
(defthm pdf-cst-name-entry-rulename (implies (pdf-cst-matchp cst "name-entry") (equal (tree-nonleaf->rulename? cst) (rulename "name-entry"))))
Theorem:
(defthm pdf-cst-font-entry-rulename (implies (pdf-cst-matchp cst "font-entry") (equal (tree-nonleaf->rulename? cst) (rulename "font-entry"))))
Theorem:
(defthm pdf-cst-font-rulename (implies (pdf-cst-matchp cst "font") (equal (tree-nonleaf->rulename? cst) (rulename "font"))))
Theorem:
(defthm pdf-cst-dict-key-rulename (implies (pdf-cst-matchp cst "dict-key") (equal (tree-nonleaf->rulename? cst) (rulename "dict-key"))))
Theorem:
(defthm pdf-cst-dict-value-rulename (implies (pdf-cst-matchp cst "dict-value") (equal (tree-nonleaf->rulename? cst) (rulename "dict-value"))))
Theorem:
(defthm pdf-cst-start-dict-rulename (implies (pdf-cst-matchp cst "start-dict") (equal (tree-nonleaf->rulename? cst) (rulename "start-dict"))))
Theorem:
(defthm pdf-cst-end-dict-rulename (implies (pdf-cst-matchp cst "end-dict") (equal (tree-nonleaf->rulename? cst) (rulename "end-dict"))))
Theorem:
(defthm pdf-cst-ws-rulename (implies (pdf-cst-matchp cst "ws") (equal (tree-nonleaf->rulename? cst) (rulename "ws"))))
Theorem:
(defthm pdf-cst-digit1-9-rulename (implies (pdf-cst-matchp cst "digit1-9") (equal (tree-nonleaf->rulename? cst) (rulename "digit1-9"))))
Theorem:
(defthm pdf-cst-digit-rulename (implies (pdf-cst-matchp cst "digit") (equal (tree-nonleaf->rulename? cst) (rulename "digit"))))
Theorem:
(defthm pdf-cst-boolean-rulename (implies (pdf-cst-matchp cst "boolean") (equal (tree-nonleaf->rulename? cst) (rulename "boolean"))))
Theorem:
(defthm pdf-cst-array-rulename (implies (pdf-cst-matchp cst "array") (equal (tree-nonleaf->rulename? cst) (rulename "array"))))
Theorem:
(defthm pdf-cst-reference-array-rulename (implies (pdf-cst-matchp cst "reference-array") (equal (tree-nonleaf->rulename? cst) (rulename "reference-array"))))
Theorem:
(defthm pdf-cst-reference-rulename (implies (pdf-cst-matchp cst "reference") (equal (tree-nonleaf->rulename? cst) (rulename "reference"))))
Theorem:
(defthm pdf-cst-rectangle-rulename (implies (pdf-cst-matchp cst "rectangle") (equal (tree-nonleaf->rulename? cst) (rulename "rectangle"))))
Theorem:
(defthm pdf-cst-left-bracket-rulename (implies (pdf-cst-matchp cst "left-bracket") (equal (tree-nonleaf->rulename? cst) (rulename "left-bracket"))))
Theorem:
(defthm pdf-cst-right-bracket-rulename (implies (pdf-cst-matchp cst "right-bracket") (equal (tree-nonleaf->rulename? cst) (rulename "right-bracket"))))
Theorem:
(defthm pdf-cst-number-rulename (implies (pdf-cst-matchp cst "number") (equal (tree-nonleaf->rulename? cst) (rulename "number"))))
Theorem:
(defthm pdf-cst-null-rulename (implies (pdf-cst-matchp cst "null") (equal (tree-nonleaf->rulename? cst) (rulename "null"))))
Theorem:
(defthm pdf-cst-name-rulename (implies (pdf-cst-matchp cst "name") (equal (tree-nonleaf->rulename? cst) (rulename "name"))))
Theorem:
(defthm pdf-cst-name-char-rulename (implies (pdf-cst-matchp cst "name-char") (equal (tree-nonleaf->rulename? cst) (rulename "name-char"))))
Theorem:
(defthm pdf-cst-real-rulename (implies (pdf-cst-matchp cst "real") (equal (tree-nonleaf->rulename? cst) (rulename "real"))))
Theorem:
(defthm pdf-cst-int-rulename (implies (pdf-cst-matchp cst "int") (equal (tree-nonleaf->rulename? cst) (rulename "int"))))
Theorem:
(defthm pdf-cst-plus-rulename (implies (pdf-cst-matchp cst "plus") (equal (tree-nonleaf->rulename? cst) (rulename "plus"))))
Theorem:
(defthm pdf-cst-minus-rulename (implies (pdf-cst-matchp cst "minus") (equal (tree-nonleaf->rulename? cst) (rulename "minus"))))
Theorem:
(defthm pdf-cst-slash-rulename (implies (pdf-cst-matchp cst "slash") (equal (tree-nonleaf->rulename? cst) (rulename "slash"))))
Theorem:
(defthm pdf-cst-backslash-rulename (implies (pdf-cst-matchp cst "backslash") (equal (tree-nonleaf->rulename? cst) (rulename "backslash"))))
Theorem:
(defthm pdf-cst-zero-rulename (implies (pdf-cst-matchp cst "zero") (equal (tree-nonleaf->rulename? cst) (rulename "zero"))))
Theorem:
(defthm pdf-cst-string-rulename (implies (pdf-cst-matchp cst "string") (equal (tree-nonleaf->rulename? cst) (rulename "string"))))
Theorem:
(defthm pdf-cst-period-rulename (implies (pdf-cst-matchp cst "period") (equal (tree-nonleaf->rulename? cst) (rulename "period"))))
Theorem:
(defthm pdf-cst-char-rulename (implies (pdf-cst-matchp cst "char") (equal (tree-nonleaf->rulename? cst) (rulename "char"))))
Theorem:
(defthm pdf-cst-pdf-branches-match-alt (implies (pdf-cst-matchp cst "pdf") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "header objects xref trailer")))
Theorem:
(defthm pdf-cst-header-branches-match-alt (implies (pdf-cst-matchp cst "header") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "pdf-marker int period int ws")))
Theorem:
(defthm pdf-cst-pdf-marker-branches-match-alt (implies (pdf-cst-matchp cst "pdf-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x25.50.44.46.45")))
Theorem:
(defthm pdf-cst-objects-branches-match-alt (implies (pdf-cst-matchp cst "objects") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*object")))
Theorem:
(defthm pdf-cst-object-branches-match-alt (implies (pdf-cst-matchp cst "object") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker")))
Theorem:
(defthm pdf-cst-obj-marker-branches-match-alt (implies (pdf-cst-matchp cst "obj-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x6F.62.6A")))
Theorem:
(defthm pdf-cst-endobj-marker-branches-match-alt (implies (pdf-cst-matchp cst "endobj-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x65.6E.64.6F.62.6A")))
Theorem:
(defthm pdf-cst-stream-branches-match-alt (implies (pdf-cst-matchp cst "stream") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "stream-marker *char endstream-marker")))
Theorem:
(defthm pdf-cst-stream-marker-branches-match-alt (implies (pdf-cst-matchp cst "stream-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x73.74.72.65.61.6D")))
Theorem:
(defthm pdf-cst-endstream-marker-branches-match-alt (implies (pdf-cst-matchp cst "endstream-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x65.6E.64.73.74.72.65.61.6D")))
Theorem:
(defthm pdf-cst-xref-branches-match-alt (implies (pdf-cst-matchp cst "xref") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "xref-marker ws zero ws int ws *xref-entry")))
Theorem:
(defthm pdf-cst-xref-entry-branches-match-alt (implies (pdf-cst-matchp cst "xref-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "xref-int ws xref-int ws use-marker")))
Theorem:
(defthm pdf-cst-use-marker-branches-match-alt (implies (pdf-cst-matchp cst "use-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x6E / %x66")))
Theorem:
(defthm pdf-cst-xref-marker-branches-match-alt (implies (pdf-cst-matchp cst "xref-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x78.72.65.66")))
Theorem:
(defthm pdf-cst-xref-int-branches-match-alt (implies (pdf-cst-matchp cst "xref-int") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*digit")))
Theorem:
(defthm pdf-cst-trailer-branches-match-alt (implies (pdf-cst-matchp cst "trailer") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "trailer-marker ws dictionary ws startxref-marker ws int eof-marker")))
Theorem:
(defthm pdf-cst-startxref-marker-branches-match-alt (implies (pdf-cst-matchp cst "startxref-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x73.74.61.72.74.78.72.65.66")))
Theorem:
(defthm pdf-cst-eof-marker-branches-match-alt (implies (pdf-cst-matchp cst "eof-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x25.25.45.4F.46")))
Theorem:
(defthm pdf-cst-trailer-dictionary-branches-match-alt (implies (pdf-cst-matchp cst "trailer-dictionary") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "start-dict *trailer-key-and-value end-dict")))
Theorem:
(defthm pdf-cst-trailer-key-and-value-branches-match-alt (implies (pdf-cst-matchp cst "trailer-key-and-value") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( %s\"/Size\" int ) / ( %s\"/Root\" reference ) / ( %s\"/Info\" reference ) / ( %s\"/ID\" left-bracket string string right-bracket )")))
Theorem:
(defthm pdf-cst-trailer-marker-branches-match-alt (implies (pdf-cst-matchp cst "trailer-marker") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x74.72.61.69.6C.65.72")))
Theorem:
(defthm pdf-cst-dictionary-branches-match-alt (implies (pdf-cst-matchp cst "dictionary") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "start-dict *dict-entry end-dict")))
Theorem:
(defthm pdf-cst-dict-entry-branches-match-alt (implies (pdf-cst-matchp cst "dict-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "type-entry / reference-entry / reference-array-entry / rectangle-entry / number-entry / name-entry / font-entry / default-entry")))
Theorem:
(defthm pdf-cst-default-entry-branches-match-alt (implies (pdf-cst-matchp cst "default-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "dict-key ws dict-value")))
Theorem:
(defthm pdf-cst-type-entry-branches-match-alt (implies (pdf-cst-matchp cst "type-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"/Type\" name")))
Theorem:
(defthm pdf-cst-reference-entry-branches-match-alt (implies (pdf-cst-matchp cst "reference-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"/Parent\" / %s\"/Pages\" / %s\"/Contents\" / %s\"/Resources\" reference")))
Theorem:
(defthm pdf-cst-reference-array-entry-branches-match-alt (implies (pdf-cst-matchp cst "reference-array-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"/Kids\" reference-array")))
Theorem:
(defthm pdf-cst-rectangle-entry-branches-match-alt (implies (pdf-cst-matchp cst "rectangle-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"/MediaBox\" / %s\"CropBox\" rectangle")))
Theorem:
(defthm pdf-cst-number-entry-branches-match-alt (implies (pdf-cst-matchp cst "number-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( %s\"/Count\" ) / ( %s\"/Length\" ) number")))
Theorem:
(defthm pdf-cst-name-entry-branches-match-alt (implies (pdf-cst-matchp cst "name-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "( %s\"/Subtype\" ) / ( %s\"/BaseFont\" ) / ( %s\"/Encoding\" ) name")))
Theorem:
(defthm pdf-cst-font-entry-branches-match-alt (implies (pdf-cst-matchp cst "font-entry") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"/Font\" font")))
Theorem:
(defthm pdf-cst-font-branches-match-alt (implies (pdf-cst-matchp cst "font") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "start-dict name reference end-dict")))
Theorem:
(defthm pdf-cst-dict-key-branches-match-alt (implies (pdf-cst-matchp cst "dict-key") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "backslash *char")))
Theorem:
(defthm pdf-cst-dict-value-branches-match-alt (implies (pdf-cst-matchp cst "dict-value") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "boolean / number / name / array / dictionary / null / rectangle / reference / string")))
Theorem:
(defthm pdf-cst-start-dict-branches-match-alt (implies (pdf-cst-matchp cst "start-dict") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x3C.3C")))
Theorem:
(defthm pdf-cst-end-dict-branches-match-alt (implies (pdf-cst-matchp cst "end-dict") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x3E.3E")))
Theorem:
(defthm pdf-cst-ws-branches-match-alt (implies (pdf-cst-matchp cst "ws") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )")))
Theorem:
(defthm pdf-cst-digit1-9-branches-match-alt (implies (pdf-cst-matchp cst "digit1-9") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x31-39")))
Theorem:
(defthm pdf-cst-digit-branches-match-alt (implies (pdf-cst-matchp cst "digit") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30-39")))
Theorem:
(defthm pdf-cst-boolean-branches-match-alt (implies (pdf-cst-matchp cst "boolean") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"true\" / %s\"false\"")))
Theorem:
(defthm pdf-cst-array-branches-match-alt (implies (pdf-cst-matchp cst "array") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "left-bracket *char right-bracket")))
Theorem:
(defthm pdf-cst-reference-array-branches-match-alt (implies (pdf-cst-matchp cst "reference-array") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "left-bracket *reference right-bracket")))
Theorem:
(defthm pdf-cst-reference-branches-match-alt (implies (pdf-cst-matchp cst "reference") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "int %x20 zero %x52")))
Theorem:
(defthm pdf-cst-rectangle-branches-match-alt (implies (pdf-cst-matchp cst "rectangle") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "left-bracket number number number number right-bracket")))
Theorem:
(defthm pdf-cst-left-bracket-branches-match-alt (implies (pdf-cst-matchp cst "left-bracket") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x5B")))
Theorem:
(defthm pdf-cst-right-bracket-branches-match-alt (implies (pdf-cst-matchp cst "right-bracket") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x5D")))
Theorem:
(defthm pdf-cst-number-branches-match-alt (implies (pdf-cst-matchp cst "number") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "[ plus / minus ] real / int")))
Theorem:
(defthm pdf-cst-null-branches-match-alt (implies (pdf-cst-matchp cst "null") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%s\"null\"")))
Theorem:
(defthm pdf-cst-name-branches-match-alt (implies (pdf-cst-matchp cst "name") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "slash name-char")))
Theorem:
(defthm pdf-cst-name-char-branches-match-alt (implies (pdf-cst-matchp cst "name-char") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20-7E")))
Theorem:
(defthm pdf-cst-real-branches-match-alt (implies (pdf-cst-matchp cst "real") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "int period int")))
Theorem:
(defthm pdf-cst-int-branches-match-alt (implies (pdf-cst-matchp cst "int") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "zero / ( digit1-9 *digit )")))
Theorem:
(defthm pdf-cst-plus-branches-match-alt (implies (pdf-cst-matchp cst "plus") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x2B")))
Theorem:
(defthm pdf-cst-minus-branches-match-alt (implies (pdf-cst-matchp cst "minus") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x2D")))
Theorem:
(defthm pdf-cst-slash-branches-match-alt (implies (pdf-cst-matchp cst "slash") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x2F")))
Theorem:
(defthm pdf-cst-backslash-branches-match-alt (implies (pdf-cst-matchp cst "backslash") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x5C")))
Theorem:
(defthm pdf-cst-zero-branches-match-alt (implies (pdf-cst-matchp cst "zero") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x30")))
Theorem:
(defthm pdf-cst-string-branches-match-alt (implies (pdf-cst-matchp cst "string") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "*char")))
Theorem:
(defthm pdf-cst-period-branches-match-alt (implies (pdf-cst-matchp cst "period") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x2E")))
Theorem:
(defthm pdf-cst-char-branches-match-alt (implies (pdf-cst-matchp cst "char") (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst) "%x20-21 / %x23-5B / %x5D-10FFFF")))
Theorem:
(defthm pdf-cst-pdf-concs (implies (pdf-cst-list-list-alt-matchp cstss "header objects xref trailer") (or (pdf-cst-list-list-conc-matchp cstss "header objects xref trailer"))))
Theorem:
(defthm pdf-cst-header-concs (implies (pdf-cst-list-list-alt-matchp cstss "pdf-marker int period int ws") (or (pdf-cst-list-list-conc-matchp cstss "pdf-marker int period int ws"))))
Theorem:
(defthm pdf-cst-pdf-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x25.50.44.46.45") (or (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45"))))
Theorem:
(defthm pdf-cst-objects-concs (implies (pdf-cst-list-list-alt-matchp cstss "*object") (or (pdf-cst-list-list-conc-matchp cstss "*object"))))
Theorem:
(defthm pdf-cst-object-concs (implies (pdf-cst-list-list-alt-matchp cstss "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker") (or (pdf-cst-list-list-conc-matchp cstss "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker"))))
Theorem:
(defthm pdf-cst-obj-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x6F.62.6A") (or (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A"))))
Theorem:
(defthm pdf-cst-endobj-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x65.6E.64.6F.62.6A") (or (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A"))))
Theorem:
(defthm pdf-cst-stream-concs (implies (pdf-cst-list-list-alt-matchp cstss "stream-marker *char endstream-marker") (or (pdf-cst-list-list-conc-matchp cstss "stream-marker *char endstream-marker"))))
Theorem:
(defthm pdf-cst-stream-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x73.74.72.65.61.6D") (or (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-endstream-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x65.6E.64.73.74.72.65.61.6D") (or (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-xref-concs (implies (pdf-cst-list-list-alt-matchp cstss "xref-marker ws zero ws int ws *xref-entry") (or (pdf-cst-list-list-conc-matchp cstss "xref-marker ws zero ws int ws *xref-entry"))))
Theorem:
(defthm pdf-cst-xref-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "xref-int ws xref-int ws use-marker") (or (pdf-cst-list-list-conc-matchp cstss "xref-int ws xref-int ws use-marker"))))
Theorem:
(defthm pdf-cst-use-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x6E / %x66") (or (pdf-cst-list-list-conc-matchp cstss "%x6E") (pdf-cst-list-list-conc-matchp cstss "%x66"))))
Theorem:
(defthm pdf-cst-xref-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x78.72.65.66") (or (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66"))))
Theorem:
(defthm pdf-cst-xref-int-concs (implies (pdf-cst-list-list-alt-matchp cstss "*digit") (or (pdf-cst-list-list-conc-matchp cstss "*digit"))))
Theorem:
(defthm pdf-cst-trailer-concs (implies (pdf-cst-list-list-alt-matchp cstss "trailer-marker ws dictionary ws startxref-marker ws int eof-marker") (or (pdf-cst-list-list-conc-matchp cstss "trailer-marker ws dictionary ws startxref-marker ws int eof-marker"))))
Theorem:
(defthm pdf-cst-startxref-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x73.74.61.72.74.78.72.65.66") (or (pdf-cst-list-list-conc-matchp cstss "%x73.74.61.72.74.78.72.65.66"))))
Theorem:
(defthm pdf-cst-eof-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x25.25.45.4F.46") (or (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46"))))
Theorem:
(defthm pdf-cst-trailer-dictionary-concs (implies (pdf-cst-list-list-alt-matchp cstss "start-dict *trailer-key-and-value end-dict") (or (pdf-cst-list-list-conc-matchp cstss "start-dict *trailer-key-and-value end-dict"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-concs (implies (pdf-cst-list-list-alt-matchp cstss "( %s\"/Size\" int ) / ( %s\"/Root\" reference ) / ( %s\"/Info\" reference ) / ( %s\"/ID\" left-bracket string string right-bracket )") (or (pdf-cst-list-list-conc-matchp cstss "( %s\"/Size\" int )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/Root\" reference )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/Info\" reference )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/ID\" left-bracket string string right-bracket )"))))
Theorem:
(defthm pdf-cst-trailer-marker-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x74.72.61.69.6C.65.72") (or (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72"))))
Theorem:
(defthm pdf-cst-dictionary-concs (implies (pdf-cst-list-list-alt-matchp cstss "start-dict *dict-entry end-dict") (or (pdf-cst-list-list-conc-matchp cstss "start-dict *dict-entry end-dict"))))
Theorem:
(defthm pdf-cst-dict-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "type-entry / reference-entry / reference-array-entry / rectangle-entry / number-entry / name-entry / font-entry / default-entry") (or (pdf-cst-list-list-conc-matchp cstss "type-entry") (pdf-cst-list-list-conc-matchp cstss "reference-entry") (pdf-cst-list-list-conc-matchp cstss "reference-array-entry") (pdf-cst-list-list-conc-matchp cstss "rectangle-entry") (pdf-cst-list-list-conc-matchp cstss "number-entry") (pdf-cst-list-list-conc-matchp cstss "name-entry") (pdf-cst-list-list-conc-matchp cstss "font-entry") (pdf-cst-list-list-conc-matchp cstss "default-entry"))))
Theorem:
(defthm pdf-cst-default-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "dict-key ws dict-value") (or (pdf-cst-list-list-conc-matchp cstss "dict-key ws dict-value"))))
Theorem:
(defthm pdf-cst-type-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"/Type\" name") (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Type\" name"))))
Theorem:
(defthm pdf-cst-reference-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"/Parent\" / %s\"/Pages\" / %s\"/Contents\" / %s\"/Resources\" reference") (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Parent\"") (pdf-cst-list-list-conc-matchp cstss "%s\"/Pages\"") (pdf-cst-list-list-conc-matchp cstss "%s\"/Contents\"") (pdf-cst-list-list-conc-matchp cstss "%s\"/Resources\" reference"))))
Theorem:
(defthm pdf-cst-reference-array-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"/Kids\" reference-array") (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Kids\" reference-array"))))
Theorem:
(defthm pdf-cst-rectangle-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"/MediaBox\" / %s\"CropBox\" rectangle") (or (pdf-cst-list-list-conc-matchp cstss "%s\"/MediaBox\"") (pdf-cst-list-list-conc-matchp cstss "%s\"CropBox\" rectangle"))))
Theorem:
(defthm pdf-cst-number-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "( %s\"/Count\" ) / ( %s\"/Length\" ) number") (or (pdf-cst-list-list-conc-matchp cstss "( %s\"/Count\" )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/Length\" ) number"))))
Theorem:
(defthm pdf-cst-name-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "( %s\"/Subtype\" ) / ( %s\"/BaseFont\" ) / ( %s\"/Encoding\" ) name") (or (pdf-cst-list-list-conc-matchp cstss "( %s\"/Subtype\" )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/BaseFont\" )") (pdf-cst-list-list-conc-matchp cstss "( %s\"/Encoding\" ) name"))))
Theorem:
(defthm pdf-cst-font-entry-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"/Font\" font") (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Font\" font"))))
Theorem:
(defthm pdf-cst-font-concs (implies (pdf-cst-list-list-alt-matchp cstss "start-dict name reference end-dict") (or (pdf-cst-list-list-conc-matchp cstss "start-dict name reference end-dict"))))
Theorem:
(defthm pdf-cst-dict-key-concs (implies (pdf-cst-list-list-alt-matchp cstss "backslash *char") (or (pdf-cst-list-list-conc-matchp cstss "backslash *char"))))
Theorem:
(defthm pdf-cst-dict-value-concs (implies (pdf-cst-list-list-alt-matchp cstss "boolean / number / name / array / dictionary / null / rectangle / reference / string") (or (pdf-cst-list-list-conc-matchp cstss "boolean") (pdf-cst-list-list-conc-matchp cstss "number") (pdf-cst-list-list-conc-matchp cstss "name") (pdf-cst-list-list-conc-matchp cstss "array") (pdf-cst-list-list-conc-matchp cstss "dictionary") (pdf-cst-list-list-conc-matchp cstss "null") (pdf-cst-list-list-conc-matchp cstss "rectangle") (pdf-cst-list-list-conc-matchp cstss "reference") (pdf-cst-list-list-conc-matchp cstss "string"))))
Theorem:
(defthm pdf-cst-start-dict-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x3C.3C") (or (pdf-cst-list-list-conc-matchp cstss "%x3C.3C"))))
Theorem:
(defthm pdf-cst-end-dict-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x3E.3E") (or (pdf-cst-list-list-conc-matchp cstss "%x3E.3E"))))
Theorem:
(defthm pdf-cst-ws-concs (implies (pdf-cst-list-list-alt-matchp cstss "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )") (or (pdf-cst-list-list-conc-matchp cstss "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )"))))
Theorem:
(defthm pdf-cst-digit1-9-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x31-39") (or (pdf-cst-list-list-conc-matchp cstss "%x31-39"))))
Theorem:
(defthm pdf-cst-digit-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x30-39") (or (pdf-cst-list-list-conc-matchp cstss "%x30-39"))))
Theorem:
(defthm pdf-cst-boolean-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"true\" / %s\"false\"") (or (pdf-cst-list-list-conc-matchp cstss "%s\"true\"") (pdf-cst-list-list-conc-matchp cstss "%s\"false\""))))
Theorem:
(defthm pdf-cst-array-concs (implies (pdf-cst-list-list-alt-matchp cstss "left-bracket *char right-bracket") (or (pdf-cst-list-list-conc-matchp cstss "left-bracket *char right-bracket"))))
Theorem:
(defthm pdf-cst-reference-array-concs (implies (pdf-cst-list-list-alt-matchp cstss "left-bracket *reference right-bracket") (or (pdf-cst-list-list-conc-matchp cstss "left-bracket *reference right-bracket"))))
Theorem:
(defthm pdf-cst-reference-concs (implies (pdf-cst-list-list-alt-matchp cstss "int %x20 zero %x52") (or (pdf-cst-list-list-conc-matchp cstss "int %x20 zero %x52"))))
Theorem:
(defthm pdf-cst-rectangle-concs (implies (pdf-cst-list-list-alt-matchp cstss "left-bracket number number number number right-bracket") (or (pdf-cst-list-list-conc-matchp cstss "left-bracket number number number number right-bracket"))))
Theorem:
(defthm pdf-cst-left-bracket-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x5B") (or (pdf-cst-list-list-conc-matchp cstss "%x5B"))))
Theorem:
(defthm pdf-cst-right-bracket-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x5D") (or (pdf-cst-list-list-conc-matchp cstss "%x5D"))))
Theorem:
(defthm pdf-cst-number-concs (implies (pdf-cst-list-list-alt-matchp cstss "[ plus / minus ] real / int") (or (pdf-cst-list-list-conc-matchp cstss "[ plus / minus ] real") (pdf-cst-list-list-conc-matchp cstss "int"))))
Theorem:
(defthm pdf-cst-null-concs (implies (pdf-cst-list-list-alt-matchp cstss "%s\"null\"") (or (pdf-cst-list-list-conc-matchp cstss "%s\"null\""))))
Theorem:
(defthm pdf-cst-name-concs (implies (pdf-cst-list-list-alt-matchp cstss "slash name-char") (or (pdf-cst-list-list-conc-matchp cstss "slash name-char"))))
Theorem:
(defthm pdf-cst-name-char-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x20-7E") (or (pdf-cst-list-list-conc-matchp cstss "%x20-7E"))))
Theorem:
(defthm pdf-cst-real-concs (implies (pdf-cst-list-list-alt-matchp cstss "int period int") (or (pdf-cst-list-list-conc-matchp cstss "int period int"))))
Theorem:
(defthm pdf-cst-int-concs (implies (pdf-cst-list-list-alt-matchp cstss "zero / ( digit1-9 *digit )") (or (pdf-cst-list-list-conc-matchp cstss "zero") (pdf-cst-list-list-conc-matchp cstss "( digit1-9 *digit )"))))
Theorem:
(defthm pdf-cst-plus-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x2B") (or (pdf-cst-list-list-conc-matchp cstss "%x2B"))))
Theorem:
(defthm pdf-cst-minus-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x2D") (or (pdf-cst-list-list-conc-matchp cstss "%x2D"))))
Theorem:
(defthm pdf-cst-slash-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x2F") (or (pdf-cst-list-list-conc-matchp cstss "%x2F"))))
Theorem:
(defthm pdf-cst-backslash-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x5C") (or (pdf-cst-list-list-conc-matchp cstss "%x5C"))))
Theorem:
(defthm pdf-cst-zero-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x30") (or (pdf-cst-list-list-conc-matchp cstss "%x30"))))
Theorem:
(defthm pdf-cst-string-concs (implies (pdf-cst-list-list-alt-matchp cstss "*char") (or (pdf-cst-list-list-conc-matchp cstss "*char"))))
Theorem:
(defthm pdf-cst-period-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x2E") (or (pdf-cst-list-list-conc-matchp cstss "%x2E"))))
Theorem:
(defthm pdf-cst-char-concs (implies (pdf-cst-list-list-alt-matchp cstss "%x20-21 / %x23-5B / %x5D-10FFFF") (or (pdf-cst-list-list-conc-matchp cstss "%x20-21") (pdf-cst-list-list-conc-matchp cstss "%x23-5B") (pdf-cst-list-list-conc-matchp cstss "%x5D-10FFFF"))))
Theorem:
(defthm pdf-cst-pdf-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x25.50.44.46.45"))))
Theorem:
(defthm pdf-cst-objects-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "*object") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "*object"))))
Theorem:
(defthm pdf-cst-obj-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x6F.62.6A"))))
Theorem:
(defthm pdf-cst-endobj-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x65.6E.64.6F.62.6A"))))
Theorem:
(defthm pdf-cst-stream-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-endstream-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.73.74.72.65.61.6D") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x65.6E.64.73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-use-marker-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x6E") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x6E"))))
Theorem:
(defthm pdf-cst-use-marker-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x66") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x66"))))
Theorem:
(defthm pdf-cst-xref-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x78.72.65.66"))))
Theorem:
(defthm pdf-cst-xref-int-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "*digit") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "*digit"))))
Theorem:
(defthm pdf-cst-startxref-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x73.74.61.72.74.78.72.65.66") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x73.74.61.72.74.78.72.65.66"))))
Theorem:
(defthm pdf-cst-eof-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x25.25.45.4F.46"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Size\" int )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/Size\" int )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Root\" reference )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/Root\" reference )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc3-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Info\" reference )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/Info\" reference )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc4-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/ID\" left-bracket string string right-bracket )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/ID\" left-bracket string string right-bracket )"))))
Theorem:
(defthm pdf-cst-trailer-marker-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x74.72.61.69.6C.65.72"))))
Theorem:
(defthm pdf-cst-dict-entry-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "type-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "type-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "reference-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "reference-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc3-matching (implies (pdf-cst-list-list-conc-matchp cstss "reference-array-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "reference-array-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc4-matching (implies (pdf-cst-list-list-conc-matchp cstss "rectangle-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "rectangle-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc5-matching (implies (pdf-cst-list-list-conc-matchp cstss "number-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "number-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc6-matching (implies (pdf-cst-list-list-conc-matchp cstss "name-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "name-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc7-matching (implies (pdf-cst-list-list-conc-matchp cstss "font-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "font-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc8-matching (implies (pdf-cst-list-list-conc-matchp cstss "default-entry") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "default-entry"))))
Theorem:
(defthm pdf-cst-reference-entry-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Parent\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"/Parent\""))))
Theorem:
(defthm pdf-cst-reference-entry-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Pages\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"/Pages\""))))
Theorem:
(defthm pdf-cst-reference-entry-conc3-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Contents\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"/Contents\""))))
Theorem:
(defthm pdf-cst-rectangle-entry-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/MediaBox\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"/MediaBox\""))))
Theorem:
(defthm pdf-cst-number-entry-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Count\" )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/Count\" )"))))
Theorem:
(defthm pdf-cst-name-entry-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Subtype\" )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/Subtype\" )"))))
Theorem:
(defthm pdf-cst-name-entry-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/BaseFont\" )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( %s\"/BaseFont\" )"))))
Theorem:
(defthm pdf-cst-dict-value-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "boolean") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "boolean"))))
Theorem:
(defthm pdf-cst-dict-value-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "number") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "number"))))
Theorem:
(defthm pdf-cst-dict-value-conc3-matching (implies (pdf-cst-list-list-conc-matchp cstss "name") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "name"))))
Theorem:
(defthm pdf-cst-dict-value-conc4-matching (implies (pdf-cst-list-list-conc-matchp cstss "array") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "array"))))
Theorem:
(defthm pdf-cst-dict-value-conc5-matching (implies (pdf-cst-list-list-conc-matchp cstss "dictionary") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "dictionary"))))
Theorem:
(defthm pdf-cst-dict-value-conc6-matching (implies (pdf-cst-list-list-conc-matchp cstss "null") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "null"))))
Theorem:
(defthm pdf-cst-dict-value-conc7-matching (implies (pdf-cst-list-list-conc-matchp cstss "rectangle") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "rectangle"))))
Theorem:
(defthm pdf-cst-dict-value-conc8-matching (implies (pdf-cst-list-list-conc-matchp cstss "reference") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "reference"))))
Theorem:
(defthm pdf-cst-dict-value-conc9-matching (implies (pdf-cst-list-list-conc-matchp cstss "string") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "string"))))
Theorem:
(defthm pdf-cst-start-dict-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x3C.3C") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x3C.3C"))))
Theorem:
(defthm pdf-cst-end-dict-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x3E.3E") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x3E.3E"))))
Theorem:
(defthm pdf-cst-ws-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )"))))
Theorem:
(defthm pdf-cst-digit1-9-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x31-39") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x31-39"))))
Theorem:
(defthm pdf-cst-digit-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x30-39") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x30-39"))))
Theorem:
(defthm pdf-cst-boolean-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"true\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"true\""))))
Theorem:
(defthm pdf-cst-boolean-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"false\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"false\""))))
Theorem:
(defthm pdf-cst-left-bracket-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x5B") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x5B"))))
Theorem:
(defthm pdf-cst-right-bracket-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x5D") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x5D"))))
Theorem:
(defthm pdf-cst-number-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "int") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "int"))))
Theorem:
(defthm pdf-cst-null-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%s\"null\"") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%s\"null\""))))
Theorem:
(defthm pdf-cst-name-char-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x20-7E") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x20-7E"))))
Theorem:
(defthm pdf-cst-int-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "zero") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "zero"))))
Theorem:
(defthm pdf-cst-int-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "( digit1-9 *digit )") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "( digit1-9 *digit )"))))
Theorem:
(defthm pdf-cst-plus-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x2B") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x2B"))))
Theorem:
(defthm pdf-cst-minus-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x2D") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x2D"))))
Theorem:
(defthm pdf-cst-slash-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x2F") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x2F"))))
Theorem:
(defthm pdf-cst-backslash-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x5C") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x5C"))))
Theorem:
(defthm pdf-cst-zero-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x30") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x30"))))
Theorem:
(defthm pdf-cst-string-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "*char") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "*char"))))
Theorem:
(defthm pdf-cst-period-conc-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x2E") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x2E"))))
Theorem:
(defthm pdf-cst-char-conc1-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x20-21") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x20-21"))))
Theorem:
(defthm pdf-cst-char-conc2-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x23-5B") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x23-5B"))))
Theorem:
(defthm pdf-cst-char-conc3-matching (implies (pdf-cst-list-list-conc-matchp cstss "%x5D-10FFFF") (and (equal (len cstss) 1) (pdf-cst-list-rep-matchp (nth 0 cstss) "%x5D-10FFFF"))))
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x25.50.44.46.45") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x25.50.44.46.45"))))
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x6F.62.6A") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x6F.62.6A"))))
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x65.6E.64.6F.62.6A") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x65.6E.64.6F.62.6A"))))
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x73.74.72.65.61.6D") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x65.6E.64.73.74.72.65.61.6D") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x65.6E.64.73.74.72.65.61.6D"))))
Theorem:
(defthm pdf-cst-use-marker-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x6E") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x6E"))))
Theorem:
(defthm pdf-cst-use-marker-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x66") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x66"))))
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x78.72.65.66") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x78.72.65.66"))))
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x73.74.61.72.74.78.72.65.66") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x73.74.61.72.74.78.72.65.66"))))
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x25.25.45.4F.46") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x25.25.45.4F.46"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/Size\" int )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/Size\" int )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/Root\" reference )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/Root\" reference )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc3-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/Info\" reference )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/Info\" reference )"))))
Theorem:
(defthm pdf-cst-trailer-key-and-value-conc4-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/ID\" left-bracket string string right-bracket )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/ID\" left-bracket string string right-bracket )"))))
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x74.72.61.69.6C.65.72") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x74.72.61.69.6C.65.72"))))
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "type-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "type-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "reference-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "reference-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-matching (implies (pdf-cst-list-rep-matchp csts "reference-array-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "reference-array-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-matching (implies (pdf-cst-list-rep-matchp csts "rectangle-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "rectangle-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-matching (implies (pdf-cst-list-rep-matchp csts "number-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "number-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-matching (implies (pdf-cst-list-rep-matchp csts "name-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "name-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-matching (implies (pdf-cst-list-rep-matchp csts "font-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "font-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-matching (implies (pdf-cst-list-rep-matchp csts "default-entry") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "default-entry"))))
Theorem:
(defthm pdf-cst-reference-entry-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"/Parent\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"/Parent\""))))
Theorem:
(defthm pdf-cst-reference-entry-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"/Pages\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"/Pages\""))))
Theorem:
(defthm pdf-cst-reference-entry-conc3-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"/Contents\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"/Contents\""))))
Theorem:
(defthm pdf-cst-rectangle-entry-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"/MediaBox\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"/MediaBox\""))))
Theorem:
(defthm pdf-cst-number-entry-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/Count\" )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/Count\" )"))))
Theorem:
(defthm pdf-cst-name-entry-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/Subtype\" )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/Subtype\" )"))))
Theorem:
(defthm pdf-cst-name-entry-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "( %s\"/BaseFont\" )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( %s\"/BaseFont\" )"))))
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "boolean") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "boolean"))))
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "number") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "number"))))
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-matching (implies (pdf-cst-list-rep-matchp csts "name") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "name"))))
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-matching (implies (pdf-cst-list-rep-matchp csts "array") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "array"))))
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-matching (implies (pdf-cst-list-rep-matchp csts "dictionary") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "dictionary"))))
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-matching (implies (pdf-cst-list-rep-matchp csts "null") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "null"))))
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-matching (implies (pdf-cst-list-rep-matchp csts "rectangle") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "rectangle"))))
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-matching (implies (pdf-cst-list-rep-matchp csts "reference") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "reference"))))
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-matching (implies (pdf-cst-list-rep-matchp csts "string") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "string"))))
Theorem:
(defthm pdf-cst-start-dict-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x3C.3C") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x3C.3C"))))
Theorem:
(defthm pdf-cst-end-dict-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x3E.3E") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x3E.3E"))))
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x31-39") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x31-39"))))
Theorem:
(defthm pdf-cst-digit-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x30-39") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x30-39"))))
Theorem:
(defthm pdf-cst-boolean-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"true\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"true\""))))
Theorem:
(defthm pdf-cst-boolean-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"false\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"false\""))))
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x5B") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x5B"))))
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x5D") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x5D"))))
Theorem:
(defthm pdf-cst-number-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "int") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "int"))))
Theorem:
(defthm pdf-cst-null-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%s\"null\"") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%s\"null\""))))
Theorem:
(defthm pdf-cst-name-char-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x20-7E") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x20-7E"))))
Theorem:
(defthm pdf-cst-int-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "zero") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "zero"))))
Theorem:
(defthm pdf-cst-int-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "( digit1-9 *digit )") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "( digit1-9 *digit )"))))
Theorem:
(defthm pdf-cst-plus-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x2B") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x2B"))))
Theorem:
(defthm pdf-cst-minus-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x2D") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x2D"))))
Theorem:
(defthm pdf-cst-slash-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x2F") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x2F"))))
Theorem:
(defthm pdf-cst-backslash-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x5C") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x5C"))))
Theorem:
(defthm pdf-cst-zero-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x30") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x30"))))
Theorem:
(defthm pdf-cst-period-conc-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x2E") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x2E"))))
Theorem:
(defthm pdf-cst-char-conc1-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x20-21") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x20-21"))))
Theorem:
(defthm pdf-cst-char-conc2-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x23-5B") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x23-5B"))))
Theorem:
(defthm pdf-cst-char-conc3-rep-matching (implies (pdf-cst-list-rep-matchp csts "%x5D-10FFFF") (and (equal (len csts) 1) (pdf-cst-matchp (nth 0 csts) "%x5D-10FFFF"))))
Theorem:
(defthm pdf-cst-dict-entry-conc-equivs (implies (pdf-cst-matchp cst "dict-entry") (and (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "type-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "type-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference-array-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference-array-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rectangle-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rectangle-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "number-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "number-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "font-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "font-entry"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "default-entry") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "default-entry"))))))
Theorem:
(defthm pdf-cst-dict-value-conc-equivs (implies (pdf-cst-matchp cst "dict-value") (and (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "boolean") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "boolean"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "number") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "number"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "array") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "array"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dictionary") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dictionary"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "null") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "null"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rectangle") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rectangle"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference"))) (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "string") (equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "string"))))))
Function:
(defun pdf-cst-dict-entry-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "dict-entry"))) (let ((__function__ 'pdf-cst-dict-entry-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "type-entry")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference-entry")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference-array-entry")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rectangle-entry")) 4) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "number-entry")) 5) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name-entry")) 6) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "font-entry")) 7) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "default-entry")) 8) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-pdf-cst-dict-entry-conc? (b* ((number (pdf-cst-dict-entry-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc?-possibilities (b* ((number (pdf-cst-dict-entry-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6) (equal number 7) (equal number 8))) :rule-classes ((:forward-chaining :trigger-terms ((pdf-cst-dict-entry-conc? cst)))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc? (tree-fix cst)) (pdf-cst-dict-entry-conc? cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc? cst) (pdf-cst-dict-entry-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-dict-entry-conc?-1-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 1) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "type-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-2-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 2) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-3-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 3) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference-array-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-4-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 4) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rectangle-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-5-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 5) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "number-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-6-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 6) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-7-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 7) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "font-entry"))))
Theorem:
(defthm pdf-cst-dict-entry-conc?-8-iff-match-conc (implies (pdf-cst-matchp cst "dict-entry") (iff (equal (pdf-cst-dict-entry-conc? cst) 8) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "default-entry"))))
Function:
(defun pdf-cst-dict-value-conc? (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "dict-value"))) (let ((__function__ 'pdf-cst-dict-value-conc?)) (declare (ignorable __function__)) (cond ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "boolean")) 1) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "number")) 2) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "name")) 3) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "array")) 4) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "dictionary")) 5) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "null")) 6) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "rectangle")) 7) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "reference")) 8) ((equal (tree-nonleaf->rulename? (nth 0 (nth 0 (tree-nonleaf->branches cst)))) (rulename "string")) 9) (t (prog2$ (acl2::impossible) 1)))))
Theorem:
(defthm posp-of-pdf-cst-dict-value-conc? (b* ((number (pdf-cst-dict-value-conc? cst))) (posp number)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc?-possibilities (b* ((number (pdf-cst-dict-value-conc? cst))) (or (equal number 1) (equal number 2) (equal number 3) (equal number 4) (equal number 5) (equal number 6) (equal number 7) (equal number 8) (equal number 9))) :rule-classes ((:forward-chaining :trigger-terms ((pdf-cst-dict-value-conc? cst)))))
Theorem:
(defthm pdf-cst-dict-value-conc?-of-tree-fix-cst (equal (pdf-cst-dict-value-conc? (tree-fix cst)) (pdf-cst-dict-value-conc? cst)))
Theorem:
(defthm pdf-cst-dict-value-conc?-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc? cst) (pdf-cst-dict-value-conc? cst-equiv))) :rule-classes :congruence)
Theorem:
(defthm pdf-cst-dict-value-conc?-1-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 1) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "boolean"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-2-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 2) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "number"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-3-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 3) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "name"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-4-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 4) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "array"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-5-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 5) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "dictionary"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-6-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 6) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "null"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-7-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 7) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "rectangle"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-8-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 8) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "reference"))))
Theorem:
(defthm pdf-cst-dict-value-conc?-9-iff-match-conc (implies (pdf-cst-matchp cst "dict-value") (iff (equal (pdf-cst-dict-value-conc? cst) 9) (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst) "string"))))
Function:
(defun pdf-cst-pdf-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "pdf"))) (let ((__function__ 'pdf-cst-pdf-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-pdf-conc (b* ((cstss (pdf-cst-pdf-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-conc-match (implies (pdf-cst-matchp cst "pdf") (b* ((cstss (pdf-cst-pdf-conc cst))) (pdf-cst-list-list-conc-matchp cstss "header objects xref trailer"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-conc-of-tree-fix-cst (equal (pdf-cst-pdf-conc (tree-fix cst)) (pdf-cst-pdf-conc cst)))
Theorem:
(defthm pdf-cst-pdf-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-pdf-conc cst) (pdf-cst-pdf-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-header-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "header"))) (let ((__function__ 'pdf-cst-header-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-header-conc (b* ((cstss (pdf-cst-header-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-header-conc-match (implies (pdf-cst-matchp cst "header") (b* ((cstss (pdf-cst-header-conc cst))) (pdf-cst-list-list-conc-matchp cstss "pdf-marker int period int ws"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-header-conc-of-tree-fix-cst (equal (pdf-cst-header-conc (tree-fix cst)) (pdf-cst-header-conc cst)))
Theorem:
(defthm pdf-cst-header-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-header-conc cst) (pdf-cst-header-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-pdf-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker"))) (let ((__function__ 'pdf-cst-pdf-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-pdf-marker-conc (b* ((cstss (pdf-cst-pdf-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-match (implies (pdf-cst-matchp cst "pdf-marker") (b* ((cstss (pdf-cst-pdf-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-of-tree-fix-cst (equal (pdf-cst-pdf-marker-conc (tree-fix cst)) (pdf-cst-pdf-marker-conc cst)))
Theorem:
(defthm pdf-cst-pdf-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-pdf-marker-conc cst) (pdf-cst-pdf-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-objects-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "objects"))) (let ((__function__ 'pdf-cst-objects-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-objects-conc (b* ((cstss (pdf-cst-objects-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-objects-conc-match (implies (pdf-cst-matchp cst "objects") (b* ((cstss (pdf-cst-objects-conc cst))) (pdf-cst-list-list-conc-matchp cstss "*object"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-objects-conc-of-tree-fix-cst (equal (pdf-cst-objects-conc (tree-fix cst)) (pdf-cst-objects-conc cst)))
Theorem:
(defthm pdf-cst-objects-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-objects-conc cst) (pdf-cst-objects-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-object-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "object"))) (let ((__function__ 'pdf-cst-object-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-object-conc (b* ((cstss (pdf-cst-object-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-object-conc-match (implies (pdf-cst-matchp cst "object") (b* ((cstss (pdf-cst-object-conc cst))) (pdf-cst-list-list-conc-matchp cstss "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-object-conc-of-tree-fix-cst (equal (pdf-cst-object-conc (tree-fix cst)) (pdf-cst-object-conc cst)))
Theorem:
(defthm pdf-cst-object-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-object-conc cst) (pdf-cst-object-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-obj-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "obj-marker"))) (let ((__function__ 'pdf-cst-obj-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-obj-marker-conc (b* ((cstss (pdf-cst-obj-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-match (implies (pdf-cst-matchp cst "obj-marker") (b* ((cstss (pdf-cst-obj-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-of-tree-fix-cst (equal (pdf-cst-obj-marker-conc (tree-fix cst)) (pdf-cst-obj-marker-conc cst)))
Theorem:
(defthm pdf-cst-obj-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-obj-marker-conc cst) (pdf-cst-obj-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endobj-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker"))) (let ((__function__ 'pdf-cst-endobj-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-endobj-marker-conc (b* ((cstss (pdf-cst-endobj-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-match (implies (pdf-cst-matchp cst "endobj-marker") (b* ((cstss (pdf-cst-endobj-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-of-tree-fix-cst (equal (pdf-cst-endobj-marker-conc (tree-fix cst)) (pdf-cst-endobj-marker-conc cst)))
Theorem:
(defthm pdf-cst-endobj-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endobj-marker-conc cst) (pdf-cst-endobj-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-stream-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "stream"))) (let ((__function__ 'pdf-cst-stream-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-stream-conc (b* ((cstss (pdf-cst-stream-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-conc-match (implies (pdf-cst-matchp cst "stream") (b* ((cstss (pdf-cst-stream-conc cst))) (pdf-cst-list-list-conc-matchp cstss "stream-marker *char endstream-marker"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-conc-of-tree-fix-cst (equal (pdf-cst-stream-conc (tree-fix cst)) (pdf-cst-stream-conc cst)))
Theorem:
(defthm pdf-cst-stream-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-stream-conc cst) (pdf-cst-stream-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-stream-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "stream-marker"))) (let ((__function__ 'pdf-cst-stream-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-stream-marker-conc (b* ((cstss (pdf-cst-stream-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-match (implies (pdf-cst-matchp cst "stream-marker") (b* ((cstss (pdf-cst-stream-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-of-tree-fix-cst (equal (pdf-cst-stream-marker-conc (tree-fix cst)) (pdf-cst-stream-marker-conc cst)))
Theorem:
(defthm pdf-cst-stream-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-stream-marker-conc cst) (pdf-cst-stream-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endstream-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker"))) (let ((__function__ 'pdf-cst-endstream-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-endstream-marker-conc (b* ((cstss (pdf-cst-endstream-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-match (implies (pdf-cst-matchp cst "endstream-marker") (b* ((cstss (pdf-cst-endstream-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-of-tree-fix-cst (equal (pdf-cst-endstream-marker-conc (tree-fix cst)) (pdf-cst-endstream-marker-conc cst)))
Theorem:
(defthm pdf-cst-endstream-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endstream-marker-conc cst) (pdf-cst-endstream-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref"))) (let ((__function__ 'pdf-cst-xref-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-xref-conc (b* ((cstss (pdf-cst-xref-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-conc-match (implies (pdf-cst-matchp cst "xref") (b* ((cstss (pdf-cst-xref-conc cst))) (pdf-cst-list-list-conc-matchp cstss "xref-marker ws zero ws int ws *xref-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-conc-of-tree-fix-cst (equal (pdf-cst-xref-conc (tree-fix cst)) (pdf-cst-xref-conc cst)))
Theorem:
(defthm pdf-cst-xref-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-conc cst) (pdf-cst-xref-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-entry-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref-entry"))) (let ((__function__ 'pdf-cst-xref-entry-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-xref-entry-conc (b* ((cstss (pdf-cst-xref-entry-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-entry-conc-match (implies (pdf-cst-matchp cst "xref-entry") (b* ((cstss (pdf-cst-xref-entry-conc cst))) (pdf-cst-list-list-conc-matchp cstss "xref-int ws xref-int ws use-marker"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-entry-conc-of-tree-fix-cst (equal (pdf-cst-xref-entry-conc (tree-fix cst)) (pdf-cst-xref-entry-conc cst)))
Theorem:
(defthm pdf-cst-xref-entry-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-entry-conc cst) (pdf-cst-xref-entry-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref-marker"))) (let ((__function__ 'pdf-cst-xref-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-xref-marker-conc (b* ((cstss (pdf-cst-xref-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-match (implies (pdf-cst-matchp cst "xref-marker") (b* ((cstss (pdf-cst-xref-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-of-tree-fix-cst (equal (pdf-cst-xref-marker-conc (tree-fix cst)) (pdf-cst-xref-marker-conc cst)))
Theorem:
(defthm pdf-cst-xref-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-marker-conc cst) (pdf-cst-xref-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-int-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref-int"))) (let ((__function__ 'pdf-cst-xref-int-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-xref-int-conc (b* ((cstss (pdf-cst-xref-int-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-int-conc-match (implies (pdf-cst-matchp cst "xref-int") (b* ((cstss (pdf-cst-xref-int-conc cst))) (pdf-cst-list-list-conc-matchp cstss "*digit"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-int-conc-of-tree-fix-cst (equal (pdf-cst-xref-int-conc (tree-fix cst)) (pdf-cst-xref-int-conc cst)))
Theorem:
(defthm pdf-cst-xref-int-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-int-conc cst) (pdf-cst-xref-int-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-trailer-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "trailer"))) (let ((__function__ 'pdf-cst-trailer-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-trailer-conc (b* ((cstss (pdf-cst-trailer-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-conc-match (implies (pdf-cst-matchp cst "trailer") (b* ((cstss (pdf-cst-trailer-conc cst))) (pdf-cst-list-list-conc-matchp cstss "trailer-marker ws dictionary ws startxref-marker ws int eof-marker"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-conc-of-tree-fix-cst (equal (pdf-cst-trailer-conc (tree-fix cst)) (pdf-cst-trailer-conc cst)))
Theorem:
(defthm pdf-cst-trailer-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-trailer-conc cst) (pdf-cst-trailer-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-startxref-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker"))) (let ((__function__ 'pdf-cst-startxref-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-startxref-marker-conc (b* ((cstss (pdf-cst-startxref-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-match (implies (pdf-cst-matchp cst "startxref-marker") (b* ((cstss (pdf-cst-startxref-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x73.74.61.72.74.78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-of-tree-fix-cst (equal (pdf-cst-startxref-marker-conc (tree-fix cst)) (pdf-cst-startxref-marker-conc cst)))
Theorem:
(defthm pdf-cst-startxref-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-startxref-marker-conc cst) (pdf-cst-startxref-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-eof-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "eof-marker"))) (let ((__function__ 'pdf-cst-eof-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-eof-marker-conc (b* ((cstss (pdf-cst-eof-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-match (implies (pdf-cst-matchp cst "eof-marker") (b* ((cstss (pdf-cst-eof-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-of-tree-fix-cst (equal (pdf-cst-eof-marker-conc (tree-fix cst)) (pdf-cst-eof-marker-conc cst)))
Theorem:
(defthm pdf-cst-eof-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-eof-marker-conc cst) (pdf-cst-eof-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-trailer-dictionary-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "trailer-dictionary"))) (let ((__function__ 'pdf-cst-trailer-dictionary-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-trailer-dictionary-conc (b* ((cstss (pdf-cst-trailer-dictionary-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-dictionary-conc-match (implies (pdf-cst-matchp cst "trailer-dictionary") (b* ((cstss (pdf-cst-trailer-dictionary-conc cst))) (pdf-cst-list-list-conc-matchp cstss "start-dict *trailer-key-and-value end-dict"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-dictionary-conc-of-tree-fix-cst (equal (pdf-cst-trailer-dictionary-conc (tree-fix cst)) (pdf-cst-trailer-dictionary-conc cst)))
Theorem:
(defthm pdf-cst-trailer-dictionary-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-trailer-dictionary-conc cst) (pdf-cst-trailer-dictionary-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-trailer-marker-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker"))) (let ((__function__ 'pdf-cst-trailer-marker-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-trailer-marker-conc (b* ((cstss (pdf-cst-trailer-marker-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-match (implies (pdf-cst-matchp cst "trailer-marker") (b* ((cstss (pdf-cst-trailer-marker-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-of-tree-fix-cst (equal (pdf-cst-trailer-marker-conc (tree-fix cst)) (pdf-cst-trailer-marker-conc cst)))
Theorem:
(defthm pdf-cst-trailer-marker-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-trailer-marker-conc cst) (pdf-cst-trailer-marker-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dictionary-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "dictionary"))) (let ((__function__ 'pdf-cst-dictionary-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dictionary-conc (b* ((cstss (pdf-cst-dictionary-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dictionary-conc-match (implies (pdf-cst-matchp cst "dictionary") (b* ((cstss (pdf-cst-dictionary-conc cst))) (pdf-cst-list-list-conc-matchp cstss "start-dict *dict-entry end-dict"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dictionary-conc-of-tree-fix-cst (equal (pdf-cst-dictionary-conc (tree-fix cst)) (pdf-cst-dictionary-conc cst)))
Theorem:
(defthm pdf-cst-dictionary-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dictionary-conc cst) (pdf-cst-dictionary-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-entry-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc1 (b* ((cstss (pdf-cst-dict-entry-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)) (b* ((cstss (pdf-cst-dict-entry-conc1 cst))) (pdf-cst-list-list-conc-matchp cstss "type-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc1 (tree-fix cst)) (pdf-cst-dict-entry-conc1 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc1 cst) (pdf-cst-dict-entry-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-entry-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc2 (b* ((cstss (pdf-cst-dict-entry-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)) (b* ((cstss (pdf-cst-dict-entry-conc2 cst))) (pdf-cst-list-list-conc-matchp cstss "reference-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc2 (tree-fix cst)) (pdf-cst-dict-entry-conc2 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc2 cst) (pdf-cst-dict-entry-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-entry-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc3 (b* ((cstss (pdf-cst-dict-entry-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)) (b* ((cstss (pdf-cst-dict-entry-conc3 cst))) (pdf-cst-list-list-conc-matchp cstss "reference-array-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc3 (tree-fix cst)) (pdf-cst-dict-entry-conc3 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc3 cst) (pdf-cst-dict-entry-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-entry-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc4 (b* ((cstss (pdf-cst-dict-entry-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)) (b* ((cstss (pdf-cst-dict-entry-conc4 cst))) (pdf-cst-list-list-conc-matchp cstss "rectangle-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc4 (tree-fix cst)) (pdf-cst-dict-entry-conc4 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc4 cst) (pdf-cst-dict-entry-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc5 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-entry-conc5)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc5 (b* ((cstss (pdf-cst-dict-entry-conc5 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)) (b* ((cstss (pdf-cst-dict-entry-conc5 cst))) (pdf-cst-list-list-conc-matchp cstss "number-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc5 (tree-fix cst)) (pdf-cst-dict-entry-conc5 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc5-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc5 cst) (pdf-cst-dict-entry-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc6 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-entry-conc6)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc6 (b* ((cstss (pdf-cst-dict-entry-conc6 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)) (b* ((cstss (pdf-cst-dict-entry-conc6 cst))) (pdf-cst-list-list-conc-matchp cstss "name-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc6 (tree-fix cst)) (pdf-cst-dict-entry-conc6 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc6-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc6 cst) (pdf-cst-dict-entry-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc7 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-entry-conc7)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc7 (b* ((cstss (pdf-cst-dict-entry-conc7 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)) (b* ((cstss (pdf-cst-dict-entry-conc7 cst))) (pdf-cst-list-list-conc-matchp cstss "font-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc7 (tree-fix cst)) (pdf-cst-dict-entry-conc7 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc7-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc7 cst) (pdf-cst-dict-entry-conc7 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc8 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-entry-conc8)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-entry-conc8 (b* ((cstss (pdf-cst-dict-entry-conc8 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)) (b* ((cstss (pdf-cst-dict-entry-conc8 cst))) (pdf-cst-list-list-conc-matchp cstss "default-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc8 (tree-fix cst)) (pdf-cst-dict-entry-conc8 cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc8-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc8 cst) (pdf-cst-dict-entry-conc8 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-default-entry-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "default-entry"))) (let ((__function__ 'pdf-cst-default-entry-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-default-entry-conc (b* ((cstss (pdf-cst-default-entry-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-default-entry-conc-match (implies (pdf-cst-matchp cst "default-entry") (b* ((cstss (pdf-cst-default-entry-conc cst))) (pdf-cst-list-list-conc-matchp cstss "dict-key ws dict-value"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-default-entry-conc-of-tree-fix-cst (equal (pdf-cst-default-entry-conc (tree-fix cst)) (pdf-cst-default-entry-conc cst)))
Theorem:
(defthm pdf-cst-default-entry-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-default-entry-conc cst) (pdf-cst-default-entry-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-type-entry-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "type-entry"))) (let ((__function__ 'pdf-cst-type-entry-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-type-entry-conc (b* ((cstss (pdf-cst-type-entry-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-type-entry-conc-match (implies (pdf-cst-matchp cst "type-entry") (b* ((cstss (pdf-cst-type-entry-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%s\"/Type\" name"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-type-entry-conc-of-tree-fix-cst (equal (pdf-cst-type-entry-conc (tree-fix cst)) (pdf-cst-type-entry-conc cst)))
Theorem:
(defthm pdf-cst-type-entry-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-type-entry-conc cst) (pdf-cst-type-entry-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-reference-array-entry-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "reference-array-entry"))) (let ((__function__ 'pdf-cst-reference-array-entry-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-reference-array-entry-conc (b* ((cstss (pdf-cst-reference-array-entry-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-array-entry-conc-match (implies (pdf-cst-matchp cst "reference-array-entry") (b* ((cstss (pdf-cst-reference-array-entry-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%s\"/Kids\" reference-array"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-array-entry-conc-of-tree-fix-cst (equal (pdf-cst-reference-array-entry-conc (tree-fix cst)) (pdf-cst-reference-array-entry-conc cst)))
Theorem:
(defthm pdf-cst-reference-array-entry-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-reference-array-entry-conc cst) (pdf-cst-reference-array-entry-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-font-entry-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "font-entry"))) (let ((__function__ 'pdf-cst-font-entry-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-font-entry-conc (b* ((cstss (pdf-cst-font-entry-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-font-entry-conc-match (implies (pdf-cst-matchp cst "font-entry") (b* ((cstss (pdf-cst-font-entry-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%s\"/Font\" font"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-font-entry-conc-of-tree-fix-cst (equal (pdf-cst-font-entry-conc (tree-fix cst)) (pdf-cst-font-entry-conc cst)))
Theorem:
(defthm pdf-cst-font-entry-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-font-entry-conc cst) (pdf-cst-font-entry-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-font-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "font"))) (let ((__function__ 'pdf-cst-font-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-font-conc (b* ((cstss (pdf-cst-font-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-font-conc-match (implies (pdf-cst-matchp cst "font") (b* ((cstss (pdf-cst-font-conc cst))) (pdf-cst-list-list-conc-matchp cstss "start-dict name reference end-dict"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-font-conc-of-tree-fix-cst (equal (pdf-cst-font-conc (tree-fix cst)) (pdf-cst-font-conc cst)))
Theorem:
(defthm pdf-cst-font-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-font-conc cst) (pdf-cst-font-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-key-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "dict-key"))) (let ((__function__ 'pdf-cst-dict-key-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-key-conc (b* ((cstss (pdf-cst-dict-key-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-key-conc-match (implies (pdf-cst-matchp cst "dict-key") (b* ((cstss (pdf-cst-dict-key-conc cst))) (pdf-cst-list-list-conc-matchp cstss "backslash *char"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-key-conc-of-tree-fix-cst (equal (pdf-cst-dict-key-conc (tree-fix cst)) (pdf-cst-dict-key-conc cst)))
Theorem:
(defthm pdf-cst-dict-key-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-key-conc cst) (pdf-cst-dict-key-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc1 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-value-conc1)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc1 (b* ((cstss (pdf-cst-dict-value-conc1 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)) (b* ((cstss (pdf-cst-dict-value-conc1 cst))) (pdf-cst-list-list-conc-matchp cstss "boolean"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-of-tree-fix-cst (equal (pdf-cst-dict-value-conc1 (tree-fix cst)) (pdf-cst-dict-value-conc1 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc1-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc1 cst) (pdf-cst-dict-value-conc1 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc2 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-value-conc2)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc2 (b* ((cstss (pdf-cst-dict-value-conc2 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)) (b* ((cstss (pdf-cst-dict-value-conc2 cst))) (pdf-cst-list-list-conc-matchp cstss "number"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-of-tree-fix-cst (equal (pdf-cst-dict-value-conc2 (tree-fix cst)) (pdf-cst-dict-value-conc2 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc2-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc2 cst) (pdf-cst-dict-value-conc2 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc3 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-value-conc3)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc3 (b* ((cstss (pdf-cst-dict-value-conc3 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)) (b* ((cstss (pdf-cst-dict-value-conc3 cst))) (pdf-cst-list-list-conc-matchp cstss "name"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-of-tree-fix-cst (equal (pdf-cst-dict-value-conc3 (tree-fix cst)) (pdf-cst-dict-value-conc3 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc3-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc3 cst) (pdf-cst-dict-value-conc3 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc4 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-value-conc4)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc4 (b* ((cstss (pdf-cst-dict-value-conc4 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)) (b* ((cstss (pdf-cst-dict-value-conc4 cst))) (pdf-cst-list-list-conc-matchp cstss "array"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-of-tree-fix-cst (equal (pdf-cst-dict-value-conc4 (tree-fix cst)) (pdf-cst-dict-value-conc4 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc4-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc4 cst) (pdf-cst-dict-value-conc4 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc5 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-value-conc5)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc5 (b* ((cstss (pdf-cst-dict-value-conc5 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)) (b* ((cstss (pdf-cst-dict-value-conc5 cst))) (pdf-cst-list-list-conc-matchp cstss "dictionary"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-of-tree-fix-cst (equal (pdf-cst-dict-value-conc5 (tree-fix cst)) (pdf-cst-dict-value-conc5 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc5-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc5 cst) (pdf-cst-dict-value-conc5 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc6 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-value-conc6)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc6 (b* ((cstss (pdf-cst-dict-value-conc6 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)) (b* ((cstss (pdf-cst-dict-value-conc6 cst))) (pdf-cst-list-list-conc-matchp cstss "null"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-of-tree-fix-cst (equal (pdf-cst-dict-value-conc6 (tree-fix cst)) (pdf-cst-dict-value-conc6 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc6-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc6 cst) (pdf-cst-dict-value-conc6 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc7 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-value-conc7)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc7 (b* ((cstss (pdf-cst-dict-value-conc7 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)) (b* ((cstss (pdf-cst-dict-value-conc7 cst))) (pdf-cst-list-list-conc-matchp cstss "rectangle"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-of-tree-fix-cst (equal (pdf-cst-dict-value-conc7 (tree-fix cst)) (pdf-cst-dict-value-conc7 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc7-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc7 cst) (pdf-cst-dict-value-conc7 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc8 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-value-conc8)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc8 (b* ((cstss (pdf-cst-dict-value-conc8 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)) (b* ((cstss (pdf-cst-dict-value-conc8 cst))) (pdf-cst-list-list-conc-matchp cstss "reference"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-of-tree-fix-cst (equal (pdf-cst-dict-value-conc8 (tree-fix cst)) (pdf-cst-dict-value-conc8 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc8-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc8 cst) (pdf-cst-dict-value-conc8 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc9 (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)))) (let ((__function__ 'pdf-cst-dict-value-conc9)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-dict-value-conc9 (b* ((cstss (pdf-cst-dict-value-conc9 cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)) (b* ((cstss (pdf-cst-dict-value-conc9 cst))) (pdf-cst-list-list-conc-matchp cstss "string"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-of-tree-fix-cst (equal (pdf-cst-dict-value-conc9 (tree-fix cst)) (pdf-cst-dict-value-conc9 cst)))
Theorem:
(defthm pdf-cst-dict-value-conc9-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc9 cst) (pdf-cst-dict-value-conc9 cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-start-dict-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "start-dict"))) (let ((__function__ 'pdf-cst-start-dict-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-start-dict-conc (b* ((cstss (pdf-cst-start-dict-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-match (implies (pdf-cst-matchp cst "start-dict") (b* ((cstss (pdf-cst-start-dict-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x3C.3C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-of-tree-fix-cst (equal (pdf-cst-start-dict-conc (tree-fix cst)) (pdf-cst-start-dict-conc cst)))
Theorem:
(defthm pdf-cst-start-dict-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-start-dict-conc cst) (pdf-cst-start-dict-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-end-dict-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "end-dict"))) (let ((__function__ 'pdf-cst-end-dict-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-end-dict-conc (b* ((cstss (pdf-cst-end-dict-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-match (implies (pdf-cst-matchp cst "end-dict") (b* ((cstss (pdf-cst-end-dict-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x3E.3E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-of-tree-fix-cst (equal (pdf-cst-end-dict-conc (tree-fix cst)) (pdf-cst-end-dict-conc cst)))
Theorem:
(defthm pdf-cst-end-dict-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-end-dict-conc cst) (pdf-cst-end-dict-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-ws-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "ws"))) (let ((__function__ 'pdf-cst-ws-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-ws-conc (b* ((cstss (pdf-cst-ws-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-ws-conc-match (implies (pdf-cst-matchp cst "ws") (b* ((cstss (pdf-cst-ws-conc cst))) (pdf-cst-list-list-conc-matchp cstss "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-ws-conc-of-tree-fix-cst (equal (pdf-cst-ws-conc (tree-fix cst)) (pdf-cst-ws-conc cst)))
Theorem:
(defthm pdf-cst-ws-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-ws-conc cst) (pdf-cst-ws-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit1-9-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit1-9"))) (let ((__function__ 'pdf-cst-digit1-9-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-digit1-9-conc (b* ((cstss (pdf-cst-digit1-9-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-match (implies (pdf-cst-matchp cst "digit1-9") (b* ((cstss (pdf-cst-digit1-9-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-of-tree-fix-cst (equal (pdf-cst-digit1-9-conc (tree-fix cst)) (pdf-cst-digit1-9-conc cst)))
Theorem:
(defthm pdf-cst-digit1-9-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit1-9-conc cst) (pdf-cst-digit1-9-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit"))) (let ((__function__ 'pdf-cst-digit-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-digit-conc (b* ((cstss (pdf-cst-digit-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-match (implies (pdf-cst-matchp cst "digit") (b* ((cstss (pdf-cst-digit-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-of-tree-fix-cst (equal (pdf-cst-digit-conc (tree-fix cst)) (pdf-cst-digit-conc cst)))
Theorem:
(defthm pdf-cst-digit-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit-conc cst) (pdf-cst-digit-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-array-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "array"))) (let ((__function__ 'pdf-cst-array-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-array-conc (b* ((cstss (pdf-cst-array-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-array-conc-match (implies (pdf-cst-matchp cst "array") (b* ((cstss (pdf-cst-array-conc cst))) (pdf-cst-list-list-conc-matchp cstss "left-bracket *char right-bracket"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-array-conc-of-tree-fix-cst (equal (pdf-cst-array-conc (tree-fix cst)) (pdf-cst-array-conc cst)))
Theorem:
(defthm pdf-cst-array-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-array-conc cst) (pdf-cst-array-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-reference-array-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "reference-array"))) (let ((__function__ 'pdf-cst-reference-array-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-reference-array-conc (b* ((cstss (pdf-cst-reference-array-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-array-conc-match (implies (pdf-cst-matchp cst "reference-array") (b* ((cstss (pdf-cst-reference-array-conc cst))) (pdf-cst-list-list-conc-matchp cstss "left-bracket *reference right-bracket"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-array-conc-of-tree-fix-cst (equal (pdf-cst-reference-array-conc (tree-fix cst)) (pdf-cst-reference-array-conc cst)))
Theorem:
(defthm pdf-cst-reference-array-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-reference-array-conc cst) (pdf-cst-reference-array-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-reference-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "reference"))) (let ((__function__ 'pdf-cst-reference-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-reference-conc (b* ((cstss (pdf-cst-reference-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-conc-match (implies (pdf-cst-matchp cst "reference") (b* ((cstss (pdf-cst-reference-conc cst))) (pdf-cst-list-list-conc-matchp cstss "int %x20 zero %x52"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-reference-conc-of-tree-fix-cst (equal (pdf-cst-reference-conc (tree-fix cst)) (pdf-cst-reference-conc cst)))
Theorem:
(defthm pdf-cst-reference-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-reference-conc cst) (pdf-cst-reference-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-rectangle-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "rectangle"))) (let ((__function__ 'pdf-cst-rectangle-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-rectangle-conc (b* ((cstss (pdf-cst-rectangle-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-rectangle-conc-match (implies (pdf-cst-matchp cst "rectangle") (b* ((cstss (pdf-cst-rectangle-conc cst))) (pdf-cst-list-list-conc-matchp cstss "left-bracket number number number number right-bracket"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-rectangle-conc-of-tree-fix-cst (equal (pdf-cst-rectangle-conc (tree-fix cst)) (pdf-cst-rectangle-conc cst)))
Theorem:
(defthm pdf-cst-rectangle-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-rectangle-conc cst) (pdf-cst-rectangle-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-left-bracket-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "left-bracket"))) (let ((__function__ 'pdf-cst-left-bracket-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-left-bracket-conc (b* ((cstss (pdf-cst-left-bracket-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-match (implies (pdf-cst-matchp cst "left-bracket") (b* ((cstss (pdf-cst-left-bracket-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x5B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-of-tree-fix-cst (equal (pdf-cst-left-bracket-conc (tree-fix cst)) (pdf-cst-left-bracket-conc cst)))
Theorem:
(defthm pdf-cst-left-bracket-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-left-bracket-conc cst) (pdf-cst-left-bracket-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-right-bracket-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "right-bracket"))) (let ((__function__ 'pdf-cst-right-bracket-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-right-bracket-conc (b* ((cstss (pdf-cst-right-bracket-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-match (implies (pdf-cst-matchp cst "right-bracket") (b* ((cstss (pdf-cst-right-bracket-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x5D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-of-tree-fix-cst (equal (pdf-cst-right-bracket-conc (tree-fix cst)) (pdf-cst-right-bracket-conc cst)))
Theorem:
(defthm pdf-cst-right-bracket-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-right-bracket-conc cst) (pdf-cst-right-bracket-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-null-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "null"))) (let ((__function__ 'pdf-cst-null-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-null-conc (b* ((cstss (pdf-cst-null-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-match (implies (pdf-cst-matchp cst "null") (b* ((cstss (pdf-cst-null-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%s\"null\""))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-of-tree-fix-cst (equal (pdf-cst-null-conc (tree-fix cst)) (pdf-cst-null-conc cst)))
Theorem:
(defthm pdf-cst-null-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-null-conc cst) (pdf-cst-null-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-name-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "name"))) (let ((__function__ 'pdf-cst-name-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-name-conc (b* ((cstss (pdf-cst-name-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-conc-match (implies (pdf-cst-matchp cst "name") (b* ((cstss (pdf-cst-name-conc cst))) (pdf-cst-list-list-conc-matchp cstss "slash name-char"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-conc-of-tree-fix-cst (equal (pdf-cst-name-conc (tree-fix cst)) (pdf-cst-name-conc cst)))
Theorem:
(defthm pdf-cst-name-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-name-conc cst) (pdf-cst-name-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-name-char-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "name-char"))) (let ((__function__ 'pdf-cst-name-char-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-name-char-conc (b* ((cstss (pdf-cst-name-char-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-match (implies (pdf-cst-matchp cst "name-char") (b* ((cstss (pdf-cst-name-char-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x20-7E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-of-tree-fix-cst (equal (pdf-cst-name-char-conc (tree-fix cst)) (pdf-cst-name-char-conc cst)))
Theorem:
(defthm pdf-cst-name-char-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-name-char-conc cst) (pdf-cst-name-char-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-real-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "real"))) (let ((__function__ 'pdf-cst-real-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-real-conc (b* ((cstss (pdf-cst-real-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-real-conc-match (implies (pdf-cst-matchp cst "real") (b* ((cstss (pdf-cst-real-conc cst))) (pdf-cst-list-list-conc-matchp cstss "int period int"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-real-conc-of-tree-fix-cst (equal (pdf-cst-real-conc (tree-fix cst)) (pdf-cst-real-conc cst)))
Theorem:
(defthm pdf-cst-real-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-real-conc cst) (pdf-cst-real-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-plus-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "plus"))) (let ((__function__ 'pdf-cst-plus-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-plus-conc (b* ((cstss (pdf-cst-plus-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-match (implies (pdf-cst-matchp cst "plus") (b* ((cstss (pdf-cst-plus-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x2B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-of-tree-fix-cst (equal (pdf-cst-plus-conc (tree-fix cst)) (pdf-cst-plus-conc cst)))
Theorem:
(defthm pdf-cst-plus-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-plus-conc cst) (pdf-cst-plus-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-minus-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "minus"))) (let ((__function__ 'pdf-cst-minus-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-minus-conc (b* ((cstss (pdf-cst-minus-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-match (implies (pdf-cst-matchp cst "minus") (b* ((cstss (pdf-cst-minus-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x2D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-of-tree-fix-cst (equal (pdf-cst-minus-conc (tree-fix cst)) (pdf-cst-minus-conc cst)))
Theorem:
(defthm pdf-cst-minus-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-minus-conc cst) (pdf-cst-minus-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-slash-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "slash"))) (let ((__function__ 'pdf-cst-slash-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-slash-conc (b* ((cstss (pdf-cst-slash-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-match (implies (pdf-cst-matchp cst "slash") (b* ((cstss (pdf-cst-slash-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x2F"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-of-tree-fix-cst (equal (pdf-cst-slash-conc (tree-fix cst)) (pdf-cst-slash-conc cst)))
Theorem:
(defthm pdf-cst-slash-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-slash-conc cst) (pdf-cst-slash-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-backslash-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "backslash"))) (let ((__function__ 'pdf-cst-backslash-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-backslash-conc (b* ((cstss (pdf-cst-backslash-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-match (implies (pdf-cst-matchp cst "backslash") (b* ((cstss (pdf-cst-backslash-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x5C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-of-tree-fix-cst (equal (pdf-cst-backslash-conc (tree-fix cst)) (pdf-cst-backslash-conc cst)))
Theorem:
(defthm pdf-cst-backslash-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-backslash-conc cst) (pdf-cst-backslash-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-zero-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "zero"))) (let ((__function__ 'pdf-cst-zero-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-zero-conc (b* ((cstss (pdf-cst-zero-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-match (implies (pdf-cst-matchp cst "zero") (b* ((cstss (pdf-cst-zero-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x30"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-of-tree-fix-cst (equal (pdf-cst-zero-conc (tree-fix cst)) (pdf-cst-zero-conc cst)))
Theorem:
(defthm pdf-cst-zero-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-zero-conc cst) (pdf-cst-zero-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-string-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "string"))) (let ((__function__ 'pdf-cst-string-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-string-conc (b* ((cstss (pdf-cst-string-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-string-conc-match (implies (pdf-cst-matchp cst "string") (b* ((cstss (pdf-cst-string-conc cst))) (pdf-cst-list-list-conc-matchp cstss "*char"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-string-conc-of-tree-fix-cst (equal (pdf-cst-string-conc (tree-fix cst)) (pdf-cst-string-conc cst)))
Theorem:
(defthm pdf-cst-string-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-string-conc cst) (pdf-cst-string-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-period-conc (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "period"))) (let ((__function__ 'pdf-cst-period-conc)) (declare (ignorable __function__)) (tree-nonleaf->branches cst)))
Theorem:
(defthm tree-list-listp-of-pdf-cst-period-conc (b* ((cstss (pdf-cst-period-conc cst))) (tree-list-listp cstss)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-match (implies (pdf-cst-matchp cst "period") (b* ((cstss (pdf-cst-period-conc cst))) (pdf-cst-list-list-conc-matchp cstss "%x2E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-of-tree-fix-cst (equal (pdf-cst-period-conc (tree-fix cst)) (pdf-cst-period-conc cst)))
Theorem:
(defthm pdf-cst-period-conc-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-period-conc cst) (pdf-cst-period-conc cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-pdf-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker"))) (let ((__function__ 'pdf-cst-pdf-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-pdf-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-pdf-marker-conc-rep (b* ((csts (pdf-cst-pdf-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-match (implies (pdf-cst-matchp cst "pdf-marker") (b* ((csts (pdf-cst-pdf-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x25.50.44.46.45"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-pdf-marker-conc-rep (tree-fix cst)) (pdf-cst-pdf-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-pdf-marker-conc-rep cst) (pdf-cst-pdf-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-obj-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "obj-marker"))) (let ((__function__ 'pdf-cst-obj-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-obj-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-obj-marker-conc-rep (b* ((csts (pdf-cst-obj-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-match (implies (pdf-cst-matchp cst "obj-marker") (b* ((csts (pdf-cst-obj-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-obj-marker-conc-rep (tree-fix cst)) (pdf-cst-obj-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-obj-marker-conc-rep cst) (pdf-cst-obj-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endobj-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker"))) (let ((__function__ 'pdf-cst-endobj-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-endobj-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-endobj-marker-conc-rep (b* ((csts (pdf-cst-endobj-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-match (implies (pdf-cst-matchp cst "endobj-marker") (b* ((csts (pdf-cst-endobj-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x65.6E.64.6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-endobj-marker-conc-rep (tree-fix cst)) (pdf-cst-endobj-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endobj-marker-conc-rep cst) (pdf-cst-endobj-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-stream-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "stream-marker"))) (let ((__function__ 'pdf-cst-stream-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-stream-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-stream-marker-conc-rep (b* ((csts (pdf-cst-stream-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-match (implies (pdf-cst-matchp cst "stream-marker") (b* ((csts (pdf-cst-stream-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-stream-marker-conc-rep (tree-fix cst)) (pdf-cst-stream-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-stream-marker-conc-rep cst) (pdf-cst-stream-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endstream-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker"))) (let ((__function__ 'pdf-cst-endstream-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-endstream-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-endstream-marker-conc-rep (b* ((csts (pdf-cst-endstream-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-match (implies (pdf-cst-matchp cst "endstream-marker") (b* ((csts (pdf-cst-endstream-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x65.6E.64.73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-endstream-marker-conc-rep (tree-fix cst)) (pdf-cst-endstream-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endstream-marker-conc-rep cst) (pdf-cst-endstream-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref-marker"))) (let ((__function__ 'pdf-cst-xref-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-xref-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-xref-marker-conc-rep (b* ((csts (pdf-cst-xref-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-match (implies (pdf-cst-matchp cst "xref-marker") (b* ((csts (pdf-cst-xref-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-xref-marker-conc-rep (tree-fix cst)) (pdf-cst-xref-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-marker-conc-rep cst) (pdf-cst-xref-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-startxref-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker"))) (let ((__function__ 'pdf-cst-startxref-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-startxref-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-startxref-marker-conc-rep (b* ((csts (pdf-cst-startxref-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-match (implies (pdf-cst-matchp cst "startxref-marker") (b* ((csts (pdf-cst-startxref-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x73.74.61.72.74.78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-startxref-marker-conc-rep (tree-fix cst)) (pdf-cst-startxref-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-startxref-marker-conc-rep cst) (pdf-cst-startxref-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-eof-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "eof-marker"))) (let ((__function__ 'pdf-cst-eof-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-eof-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-eof-marker-conc-rep (b* ((csts (pdf-cst-eof-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-match (implies (pdf-cst-matchp cst "eof-marker") (b* ((csts (pdf-cst-eof-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x25.25.45.4F.46"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-eof-marker-conc-rep (tree-fix cst)) (pdf-cst-eof-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-eof-marker-conc-rep cst) (pdf-cst-eof-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-trailer-marker-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker"))) (let ((__function__ 'pdf-cst-trailer-marker-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-trailer-marker-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-trailer-marker-conc-rep (b* ((csts (pdf-cst-trailer-marker-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-match (implies (pdf-cst-matchp cst "trailer-marker") (b* ((csts (pdf-cst-trailer-marker-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x74.72.61.69.6C.65.72"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-of-tree-fix-cst (equal (pdf-cst-trailer-marker-conc-rep (tree-fix cst)) (pdf-cst-trailer-marker-conc-rep cst)))
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-trailer-marker-conc-rep cst) (pdf-cst-trailer-marker-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-entry-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc1 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc1-rep (b* ((csts (pdf-cst-dict-entry-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)) (b* ((csts (pdf-cst-dict-entry-conc1-rep cst))) (pdf-cst-list-rep-matchp csts "type-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc1-rep (tree-fix cst)) (pdf-cst-dict-entry-conc1-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc1-rep cst) (pdf-cst-dict-entry-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-entry-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc2 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc2-rep (b* ((csts (pdf-cst-dict-entry-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)) (b* ((csts (pdf-cst-dict-entry-conc2-rep cst))) (pdf-cst-list-rep-matchp csts "reference-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc2-rep (tree-fix cst)) (pdf-cst-dict-entry-conc2-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc2-rep cst) (pdf-cst-dict-entry-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-entry-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc3 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc3-rep (b* ((csts (pdf-cst-dict-entry-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)) (b* ((csts (pdf-cst-dict-entry-conc3-rep cst))) (pdf-cst-list-rep-matchp csts "reference-array-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc3-rep (tree-fix cst)) (pdf-cst-dict-entry-conc3-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc3-rep cst) (pdf-cst-dict-entry-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-entry-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc4 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc4-rep (b* ((csts (pdf-cst-dict-entry-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)) (b* ((csts (pdf-cst-dict-entry-conc4-rep cst))) (pdf-cst-list-rep-matchp csts "rectangle-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc4-rep (tree-fix cst)) (pdf-cst-dict-entry-conc4-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc4-rep cst) (pdf-cst-dict-entry-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc5-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-entry-conc5-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc5 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc5-rep (b* ((csts (pdf-cst-dict-entry-conc5-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)) (b* ((csts (pdf-cst-dict-entry-conc5-rep cst))) (pdf-cst-list-rep-matchp csts "number-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc5-rep (tree-fix cst)) (pdf-cst-dict-entry-conc5-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc5-rep cst) (pdf-cst-dict-entry-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc6-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-entry-conc6-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc6 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc6-rep (b* ((csts (pdf-cst-dict-entry-conc6-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)) (b* ((csts (pdf-cst-dict-entry-conc6-rep cst))) (pdf-cst-list-rep-matchp csts "name-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc6-rep (tree-fix cst)) (pdf-cst-dict-entry-conc6-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc6-rep cst) (pdf-cst-dict-entry-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc7-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-entry-conc7-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc7 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc7-rep (b* ((csts (pdf-cst-dict-entry-conc7-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)) (b* ((csts (pdf-cst-dict-entry-conc7-rep cst))) (pdf-cst-list-rep-matchp csts "font-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc7-rep (tree-fix cst)) (pdf-cst-dict-entry-conc7-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc7-rep cst) (pdf-cst-dict-entry-conc7-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc8-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-entry-conc8-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc8 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-entry-conc8-rep (b* ((csts (pdf-cst-dict-entry-conc8-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)) (b* ((csts (pdf-cst-dict-entry-conc8-rep cst))) (pdf-cst-list-rep-matchp csts "default-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc8-rep (tree-fix cst)) (pdf-cst-dict-entry-conc8-rep cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc8-rep cst) (pdf-cst-dict-entry-conc8-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc1-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-value-conc1-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc1 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc1-rep (b* ((csts (pdf-cst-dict-value-conc1-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)) (b* ((csts (pdf-cst-dict-value-conc1-rep cst))) (pdf-cst-list-rep-matchp csts "boolean"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc1-rep (tree-fix cst)) (pdf-cst-dict-value-conc1-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc1-rep cst) (pdf-cst-dict-value-conc1-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc2-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-value-conc2-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc2 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc2-rep (b* ((csts (pdf-cst-dict-value-conc2-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)) (b* ((csts (pdf-cst-dict-value-conc2-rep cst))) (pdf-cst-list-rep-matchp csts "number"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc2-rep (tree-fix cst)) (pdf-cst-dict-value-conc2-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc2-rep cst) (pdf-cst-dict-value-conc2-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc3-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-value-conc3-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc3 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc3-rep (b* ((csts (pdf-cst-dict-value-conc3-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)) (b* ((csts (pdf-cst-dict-value-conc3-rep cst))) (pdf-cst-list-rep-matchp csts "name"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc3-rep (tree-fix cst)) (pdf-cst-dict-value-conc3-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc3-rep cst) (pdf-cst-dict-value-conc3-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc4-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-value-conc4-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc4 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc4-rep (b* ((csts (pdf-cst-dict-value-conc4-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)) (b* ((csts (pdf-cst-dict-value-conc4-rep cst))) (pdf-cst-list-rep-matchp csts "array"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc4-rep (tree-fix cst)) (pdf-cst-dict-value-conc4-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc4-rep cst) (pdf-cst-dict-value-conc4-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc5-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-value-conc5-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc5 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc5-rep (b* ((csts (pdf-cst-dict-value-conc5-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)) (b* ((csts (pdf-cst-dict-value-conc5-rep cst))) (pdf-cst-list-rep-matchp csts "dictionary"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc5-rep (tree-fix cst)) (pdf-cst-dict-value-conc5-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc5-rep cst) (pdf-cst-dict-value-conc5-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc6-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-value-conc6-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc6 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc6-rep (b* ((csts (pdf-cst-dict-value-conc6-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)) (b* ((csts (pdf-cst-dict-value-conc6-rep cst))) (pdf-cst-list-rep-matchp csts "null"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc6-rep (tree-fix cst)) (pdf-cst-dict-value-conc6-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc6-rep cst) (pdf-cst-dict-value-conc6-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc7-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-value-conc7-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc7 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc7-rep (b* ((csts (pdf-cst-dict-value-conc7-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)) (b* ((csts (pdf-cst-dict-value-conc7-rep cst))) (pdf-cst-list-rep-matchp csts "rectangle"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc7-rep (tree-fix cst)) (pdf-cst-dict-value-conc7-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc7-rep cst) (pdf-cst-dict-value-conc7-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc8-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-value-conc8-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc8 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc8-rep (b* ((csts (pdf-cst-dict-value-conc8-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)) (b* ((csts (pdf-cst-dict-value-conc8-rep cst))) (pdf-cst-list-rep-matchp csts "reference"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc8-rep (tree-fix cst)) (pdf-cst-dict-value-conc8-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc8-rep cst) (pdf-cst-dict-value-conc8-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc9-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)))) (let ((__function__ 'pdf-cst-dict-value-conc9-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-dict-value-conc9 cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-dict-value-conc9-rep (b* ((csts (pdf-cst-dict-value-conc9-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)) (b* ((csts (pdf-cst-dict-value-conc9-rep cst))) (pdf-cst-list-rep-matchp csts "string"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-of-tree-fix-cst (equal (pdf-cst-dict-value-conc9-rep (tree-fix cst)) (pdf-cst-dict-value-conc9-rep cst)))
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc9-rep cst) (pdf-cst-dict-value-conc9-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-start-dict-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "start-dict"))) (let ((__function__ 'pdf-cst-start-dict-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-start-dict-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-start-dict-conc-rep (b* ((csts (pdf-cst-start-dict-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-rep-match (implies (pdf-cst-matchp cst "start-dict") (b* ((csts (pdf-cst-start-dict-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x3C.3C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-rep-of-tree-fix-cst (equal (pdf-cst-start-dict-conc-rep (tree-fix cst)) (pdf-cst-start-dict-conc-rep cst)))
Theorem:
(defthm pdf-cst-start-dict-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-start-dict-conc-rep cst) (pdf-cst-start-dict-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-end-dict-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "end-dict"))) (let ((__function__ 'pdf-cst-end-dict-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-end-dict-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-end-dict-conc-rep (b* ((csts (pdf-cst-end-dict-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-rep-match (implies (pdf-cst-matchp cst "end-dict") (b* ((csts (pdf-cst-end-dict-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x3E.3E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-rep-of-tree-fix-cst (equal (pdf-cst-end-dict-conc-rep (tree-fix cst)) (pdf-cst-end-dict-conc-rep cst)))
Theorem:
(defthm pdf-cst-end-dict-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-end-dict-conc-rep cst) (pdf-cst-end-dict-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit1-9-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit1-9"))) (let ((__function__ 'pdf-cst-digit1-9-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-digit1-9-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-digit1-9-conc-rep (b* ((csts (pdf-cst-digit1-9-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-match (implies (pdf-cst-matchp cst "digit1-9") (b* ((csts (pdf-cst-digit1-9-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-of-tree-fix-cst (equal (pdf-cst-digit1-9-conc-rep (tree-fix cst)) (pdf-cst-digit1-9-conc-rep cst)))
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit1-9-conc-rep cst) (pdf-cst-digit1-9-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit"))) (let ((__function__ 'pdf-cst-digit-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-digit-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-digit-conc-rep (b* ((csts (pdf-cst-digit-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-rep-match (implies (pdf-cst-matchp cst "digit") (b* ((csts (pdf-cst-digit-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-rep-of-tree-fix-cst (equal (pdf-cst-digit-conc-rep (tree-fix cst)) (pdf-cst-digit-conc-rep cst)))
Theorem:
(defthm pdf-cst-digit-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit-conc-rep cst) (pdf-cst-digit-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-left-bracket-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "left-bracket"))) (let ((__function__ 'pdf-cst-left-bracket-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-left-bracket-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-left-bracket-conc-rep (b* ((csts (pdf-cst-left-bracket-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-match (implies (pdf-cst-matchp cst "left-bracket") (b* ((csts (pdf-cst-left-bracket-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x5B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-of-tree-fix-cst (equal (pdf-cst-left-bracket-conc-rep (tree-fix cst)) (pdf-cst-left-bracket-conc-rep cst)))
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-left-bracket-conc-rep cst) (pdf-cst-left-bracket-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-right-bracket-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "right-bracket"))) (let ((__function__ 'pdf-cst-right-bracket-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-right-bracket-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-right-bracket-conc-rep (b* ((csts (pdf-cst-right-bracket-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-match (implies (pdf-cst-matchp cst "right-bracket") (b* ((csts (pdf-cst-right-bracket-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x5D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-of-tree-fix-cst (equal (pdf-cst-right-bracket-conc-rep (tree-fix cst)) (pdf-cst-right-bracket-conc-rep cst)))
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-right-bracket-conc-rep cst) (pdf-cst-right-bracket-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-null-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "null"))) (let ((__function__ 'pdf-cst-null-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-null-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-null-conc-rep (b* ((csts (pdf-cst-null-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-rep-match (implies (pdf-cst-matchp cst "null") (b* ((csts (pdf-cst-null-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%s\"null\""))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-rep-of-tree-fix-cst (equal (pdf-cst-null-conc-rep (tree-fix cst)) (pdf-cst-null-conc-rep cst)))
Theorem:
(defthm pdf-cst-null-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-null-conc-rep cst) (pdf-cst-null-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-name-char-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "name-char"))) (let ((__function__ 'pdf-cst-name-char-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-name-char-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-name-char-conc-rep (b* ((csts (pdf-cst-name-char-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-rep-match (implies (pdf-cst-matchp cst "name-char") (b* ((csts (pdf-cst-name-char-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x20-7E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-rep-of-tree-fix-cst (equal (pdf-cst-name-char-conc-rep (tree-fix cst)) (pdf-cst-name-char-conc-rep cst)))
Theorem:
(defthm pdf-cst-name-char-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-name-char-conc-rep cst) (pdf-cst-name-char-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-plus-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "plus"))) (let ((__function__ 'pdf-cst-plus-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-plus-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-plus-conc-rep (b* ((csts (pdf-cst-plus-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-rep-match (implies (pdf-cst-matchp cst "plus") (b* ((csts (pdf-cst-plus-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x2B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-rep-of-tree-fix-cst (equal (pdf-cst-plus-conc-rep (tree-fix cst)) (pdf-cst-plus-conc-rep cst)))
Theorem:
(defthm pdf-cst-plus-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-plus-conc-rep cst) (pdf-cst-plus-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-minus-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "minus"))) (let ((__function__ 'pdf-cst-minus-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-minus-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-minus-conc-rep (b* ((csts (pdf-cst-minus-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-rep-match (implies (pdf-cst-matchp cst "minus") (b* ((csts (pdf-cst-minus-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x2D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-rep-of-tree-fix-cst (equal (pdf-cst-minus-conc-rep (tree-fix cst)) (pdf-cst-minus-conc-rep cst)))
Theorem:
(defthm pdf-cst-minus-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-minus-conc-rep cst) (pdf-cst-minus-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-slash-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "slash"))) (let ((__function__ 'pdf-cst-slash-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-slash-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-slash-conc-rep (b* ((csts (pdf-cst-slash-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-rep-match (implies (pdf-cst-matchp cst "slash") (b* ((csts (pdf-cst-slash-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x2F"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-rep-of-tree-fix-cst (equal (pdf-cst-slash-conc-rep (tree-fix cst)) (pdf-cst-slash-conc-rep cst)))
Theorem:
(defthm pdf-cst-slash-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-slash-conc-rep cst) (pdf-cst-slash-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-backslash-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "backslash"))) (let ((__function__ 'pdf-cst-backslash-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-backslash-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-backslash-conc-rep (b* ((csts (pdf-cst-backslash-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-rep-match (implies (pdf-cst-matchp cst "backslash") (b* ((csts (pdf-cst-backslash-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x5C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-rep-of-tree-fix-cst (equal (pdf-cst-backslash-conc-rep (tree-fix cst)) (pdf-cst-backslash-conc-rep cst)))
Theorem:
(defthm pdf-cst-backslash-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-backslash-conc-rep cst) (pdf-cst-backslash-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-zero-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "zero"))) (let ((__function__ 'pdf-cst-zero-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-zero-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-zero-conc-rep (b* ((csts (pdf-cst-zero-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-rep-match (implies (pdf-cst-matchp cst "zero") (b* ((csts (pdf-cst-zero-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x30"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-rep-of-tree-fix-cst (equal (pdf-cst-zero-conc-rep (tree-fix cst)) (pdf-cst-zero-conc-rep cst)))
Theorem:
(defthm pdf-cst-zero-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-zero-conc-rep cst) (pdf-cst-zero-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-period-conc-rep (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "period"))) (let ((__function__ 'pdf-cst-period-conc-rep)) (declare (ignorable __function__)) (tree-list-fix (nth 0 (pdf-cst-period-conc cst)))))
Theorem:
(defthm tree-listp-of-pdf-cst-period-conc-rep (b* ((csts (pdf-cst-period-conc-rep cst))) (tree-listp csts)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-rep-match (implies (pdf-cst-matchp cst "period") (b* ((csts (pdf-cst-period-conc-rep cst))) (pdf-cst-list-rep-matchp csts "%x2E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-rep-of-tree-fix-cst (equal (pdf-cst-period-conc-rep (tree-fix cst)) (pdf-cst-period-conc-rep cst)))
Theorem:
(defthm pdf-cst-period-conc-rep-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-period-conc-rep cst) (pdf-cst-period-conc-rep cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-pdf-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker"))) (let ((__function__ 'pdf-cst-pdf-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-pdf-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-pdf-marker-conc-rep-elem (b* ((cst1 (pdf-cst-pdf-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "pdf-marker") (b* ((cst1 (pdf-cst-pdf-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x25.50.44.46.45"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-pdf-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-pdf-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-pdf-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-pdf-marker-conc-rep-elem cst) (pdf-cst-pdf-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-obj-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "obj-marker"))) (let ((__function__ 'pdf-cst-obj-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-obj-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-obj-marker-conc-rep-elem (b* ((cst1 (pdf-cst-obj-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "obj-marker") (b* ((cst1 (pdf-cst-obj-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-obj-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-obj-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-obj-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-obj-marker-conc-rep-elem cst) (pdf-cst-obj-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endobj-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker"))) (let ((__function__ 'pdf-cst-endobj-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-endobj-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-endobj-marker-conc-rep-elem (b* ((cst1 (pdf-cst-endobj-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "endobj-marker") (b* ((cst1 (pdf-cst-endobj-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x65.6E.64.6F.62.6A"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-endobj-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-endobj-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-endobj-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endobj-marker-conc-rep-elem cst) (pdf-cst-endobj-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-stream-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "stream-marker"))) (let ((__function__ 'pdf-cst-stream-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-stream-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-stream-marker-conc-rep-elem (b* ((cst1 (pdf-cst-stream-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "stream-marker") (b* ((cst1 (pdf-cst-stream-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-stream-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-stream-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-stream-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-stream-marker-conc-rep-elem cst) (pdf-cst-stream-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-endstream-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker"))) (let ((__function__ 'pdf-cst-endstream-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-endstream-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-endstream-marker-conc-rep-elem (b* ((cst1 (pdf-cst-endstream-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "endstream-marker") (b* ((cst1 (pdf-cst-endstream-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x65.6E.64.73.74.72.65.61.6D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-endstream-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-endstream-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-endstream-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-endstream-marker-conc-rep-elem cst) (pdf-cst-endstream-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-xref-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "xref-marker"))) (let ((__function__ 'pdf-cst-xref-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-xref-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-xref-marker-conc-rep-elem (b* ((cst1 (pdf-cst-xref-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "xref-marker") (b* ((cst1 (pdf-cst-xref-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-xref-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-xref-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-xref-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-xref-marker-conc-rep-elem cst) (pdf-cst-xref-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-startxref-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker"))) (let ((__function__ 'pdf-cst-startxref-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-startxref-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-startxref-marker-conc-rep-elem (b* ((cst1 (pdf-cst-startxref-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "startxref-marker") (b* ((cst1 (pdf-cst-startxref-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x73.74.61.72.74.78.72.65.66"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-startxref-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-startxref-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-startxref-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-startxref-marker-conc-rep-elem cst) (pdf-cst-startxref-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-eof-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "eof-marker"))) (let ((__function__ 'pdf-cst-eof-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-eof-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-eof-marker-conc-rep-elem (b* ((cst1 (pdf-cst-eof-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "eof-marker") (b* ((cst1 (pdf-cst-eof-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x25.25.45.4F.46"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-eof-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-eof-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-eof-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-eof-marker-conc-rep-elem cst) (pdf-cst-eof-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-trailer-marker-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker"))) (let ((__function__ 'pdf-cst-trailer-marker-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-trailer-marker-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-trailer-marker-conc-rep-elem (b* ((cst1 (pdf-cst-trailer-marker-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-elem-match (implies (pdf-cst-matchp cst "trailer-marker") (b* ((cst1 (pdf-cst-trailer-marker-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x74.72.61.69.6C.65.72"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-trailer-marker-conc-rep-elem (tree-fix cst)) (pdf-cst-trailer-marker-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-trailer-marker-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-trailer-marker-conc-rep-elem cst) (pdf-cst-trailer-marker-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-entry-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc1-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc1-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 1)) (b* ((cst1 (pdf-cst-dict-entry-conc1-rep-elem cst))) (pdf-cst-matchp cst1 "type-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc1-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc1-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc1-rep-elem cst) (pdf-cst-dict-entry-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-entry-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc2-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc2-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 2)) (b* ((cst1 (pdf-cst-dict-entry-conc2-rep-elem cst))) (pdf-cst-matchp cst1 "reference-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc2-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc2-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc2-rep-elem cst) (pdf-cst-dict-entry-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-entry-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc3-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc3-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 3)) (b* ((cst1 (pdf-cst-dict-entry-conc3-rep-elem cst))) (pdf-cst-matchp cst1 "reference-array-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc3-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc3-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc3-rep-elem cst) (pdf-cst-dict-entry-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-entry-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc4-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc4-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 4)) (b* ((cst1 (pdf-cst-dict-entry-conc4-rep-elem cst))) (pdf-cst-matchp cst1 "rectangle-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc4-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc4-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc4-rep-elem cst) (pdf-cst-dict-entry-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc5-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-entry-conc5-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc5-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc5-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc5-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 5)) (b* ((cst1 (pdf-cst-dict-entry-conc5-rep-elem cst))) (pdf-cst-matchp cst1 "number-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc5-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc5-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc5-rep-elem cst) (pdf-cst-dict-entry-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc6-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-entry-conc6-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc6-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc6-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc6-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 6)) (b* ((cst1 (pdf-cst-dict-entry-conc6-rep-elem cst))) (pdf-cst-matchp cst1 "name-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc6-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc6-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc6-rep-elem cst) (pdf-cst-dict-entry-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc7-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-entry-conc7-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc7-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc7-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc7-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 7)) (b* ((cst1 (pdf-cst-dict-entry-conc7-rep-elem cst))) (pdf-cst-matchp cst1 "font-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc7-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc7-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc7-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc7-rep-elem cst) (pdf-cst-dict-entry-conc7-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-entry-conc8-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-entry-conc8-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-entry-conc8-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-entry-conc8-rep-elem (b* ((cst1 (pdf-cst-dict-entry-conc8-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-entry") (equal (pdf-cst-dict-entry-conc? cst) 8)) (b* ((cst1 (pdf-cst-dict-entry-conc8-rep-elem cst))) (pdf-cst-matchp cst1 "default-entry"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-entry-conc8-rep-elem (tree-fix cst)) (pdf-cst-dict-entry-conc8-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-entry-conc8-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-entry-conc8-rep-elem cst) (pdf-cst-dict-entry-conc8-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc1-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)))) (let ((__function__ 'pdf-cst-dict-value-conc1-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc1-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc1-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc1-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 1)) (b* ((cst1 (pdf-cst-dict-value-conc1-rep-elem cst))) (pdf-cst-matchp cst1 "boolean"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc1-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc1-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc1-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc1-rep-elem cst) (pdf-cst-dict-value-conc1-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc2-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)))) (let ((__function__ 'pdf-cst-dict-value-conc2-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc2-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc2-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc2-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 2)) (b* ((cst1 (pdf-cst-dict-value-conc2-rep-elem cst))) (pdf-cst-matchp cst1 "number"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc2-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc2-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc2-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc2-rep-elem cst) (pdf-cst-dict-value-conc2-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc3-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)))) (let ((__function__ 'pdf-cst-dict-value-conc3-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc3-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc3-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc3-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 3)) (b* ((cst1 (pdf-cst-dict-value-conc3-rep-elem cst))) (pdf-cst-matchp cst1 "name"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc3-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc3-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc3-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc3-rep-elem cst) (pdf-cst-dict-value-conc3-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc4-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)))) (let ((__function__ 'pdf-cst-dict-value-conc4-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc4-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc4-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc4-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 4)) (b* ((cst1 (pdf-cst-dict-value-conc4-rep-elem cst))) (pdf-cst-matchp cst1 "array"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc4-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc4-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc4-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc4-rep-elem cst) (pdf-cst-dict-value-conc4-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc5-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)))) (let ((__function__ 'pdf-cst-dict-value-conc5-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc5-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc5-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc5-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 5)) (b* ((cst1 (pdf-cst-dict-value-conc5-rep-elem cst))) (pdf-cst-matchp cst1 "dictionary"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc5-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc5-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc5-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc5-rep-elem cst) (pdf-cst-dict-value-conc5-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc6-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)))) (let ((__function__ 'pdf-cst-dict-value-conc6-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc6-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc6-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc6-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 6)) (b* ((cst1 (pdf-cst-dict-value-conc6-rep-elem cst))) (pdf-cst-matchp cst1 "null"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc6-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc6-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc6-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc6-rep-elem cst) (pdf-cst-dict-value-conc6-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc7-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)))) (let ((__function__ 'pdf-cst-dict-value-conc7-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc7-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc7-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc7-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 7)) (b* ((cst1 (pdf-cst-dict-value-conc7-rep-elem cst))) (pdf-cst-matchp cst1 "rectangle"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc7-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc7-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc7-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc7-rep-elem cst) (pdf-cst-dict-value-conc7-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc8-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)))) (let ((__function__ 'pdf-cst-dict-value-conc8-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc8-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc8-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc8-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 8)) (b* ((cst1 (pdf-cst-dict-value-conc8-rep-elem cst))) (pdf-cst-matchp cst1 "reference"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc8-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc8-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc8-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc8-rep-elem cst) (pdf-cst-dict-value-conc8-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-dict-value-conc9-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)))) (let ((__function__ 'pdf-cst-dict-value-conc9-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-dict-value-conc9-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-dict-value-conc9-rep-elem (b* ((cst1 (pdf-cst-dict-value-conc9-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-elem-match (implies (and (pdf-cst-matchp cst "dict-value") (equal (pdf-cst-dict-value-conc? cst) 9)) (b* ((cst1 (pdf-cst-dict-value-conc9-rep-elem cst))) (pdf-cst-matchp cst1 "string"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-elem-of-tree-fix-cst (equal (pdf-cst-dict-value-conc9-rep-elem (tree-fix cst)) (pdf-cst-dict-value-conc9-rep-elem cst)))
Theorem:
(defthm pdf-cst-dict-value-conc9-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-dict-value-conc9-rep-elem cst) (pdf-cst-dict-value-conc9-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-start-dict-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "start-dict"))) (let ((__function__ 'pdf-cst-start-dict-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-start-dict-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-start-dict-conc-rep-elem (b* ((cst1 (pdf-cst-start-dict-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-rep-elem-match (implies (pdf-cst-matchp cst "start-dict") (b* ((cst1 (pdf-cst-start-dict-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x3C.3C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-start-dict-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-start-dict-conc-rep-elem (tree-fix cst)) (pdf-cst-start-dict-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-start-dict-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-start-dict-conc-rep-elem cst) (pdf-cst-start-dict-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-end-dict-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "end-dict"))) (let ((__function__ 'pdf-cst-end-dict-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-end-dict-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-end-dict-conc-rep-elem (b* ((cst1 (pdf-cst-end-dict-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-rep-elem-match (implies (pdf-cst-matchp cst "end-dict") (b* ((cst1 (pdf-cst-end-dict-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x3E.3E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-end-dict-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-end-dict-conc-rep-elem (tree-fix cst)) (pdf-cst-end-dict-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-end-dict-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-end-dict-conc-rep-elem cst) (pdf-cst-end-dict-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit1-9-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit1-9"))) (let ((__function__ 'pdf-cst-digit1-9-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-digit1-9-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-digit1-9-conc-rep-elem (b* ((cst1 (pdf-cst-digit1-9-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-elem-match (implies (pdf-cst-matchp cst "digit1-9") (b* ((cst1 (pdf-cst-digit1-9-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x31-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-digit1-9-conc-rep-elem (tree-fix cst)) (pdf-cst-digit1-9-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-digit1-9-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit1-9-conc-rep-elem cst) (pdf-cst-digit1-9-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-digit-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "digit"))) (let ((__function__ 'pdf-cst-digit-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-digit-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-digit-conc-rep-elem (b* ((cst1 (pdf-cst-digit-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-rep-elem-match (implies (pdf-cst-matchp cst "digit") (b* ((cst1 (pdf-cst-digit-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x30-39"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-digit-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-digit-conc-rep-elem (tree-fix cst)) (pdf-cst-digit-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-digit-conc-rep-elem cst) (pdf-cst-digit-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-left-bracket-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "left-bracket"))) (let ((__function__ 'pdf-cst-left-bracket-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-left-bracket-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-left-bracket-conc-rep-elem (b* ((cst1 (pdf-cst-left-bracket-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-elem-match (implies (pdf-cst-matchp cst "left-bracket") (b* ((cst1 (pdf-cst-left-bracket-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x5B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-left-bracket-conc-rep-elem (tree-fix cst)) (pdf-cst-left-bracket-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-left-bracket-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-left-bracket-conc-rep-elem cst) (pdf-cst-left-bracket-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-right-bracket-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "right-bracket"))) (let ((__function__ 'pdf-cst-right-bracket-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-right-bracket-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-right-bracket-conc-rep-elem (b* ((cst1 (pdf-cst-right-bracket-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-elem-match (implies (pdf-cst-matchp cst "right-bracket") (b* ((cst1 (pdf-cst-right-bracket-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x5D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-right-bracket-conc-rep-elem (tree-fix cst)) (pdf-cst-right-bracket-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-right-bracket-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-right-bracket-conc-rep-elem cst) (pdf-cst-right-bracket-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-null-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "null"))) (let ((__function__ 'pdf-cst-null-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-null-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-null-conc-rep-elem (b* ((cst1 (pdf-cst-null-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-rep-elem-match (implies (pdf-cst-matchp cst "null") (b* ((cst1 (pdf-cst-null-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%s\"null\""))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-null-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-null-conc-rep-elem (tree-fix cst)) (pdf-cst-null-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-null-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-null-conc-rep-elem cst) (pdf-cst-null-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-name-char-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "name-char"))) (let ((__function__ 'pdf-cst-name-char-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-name-char-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-name-char-conc-rep-elem (b* ((cst1 (pdf-cst-name-char-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-rep-elem-match (implies (pdf-cst-matchp cst "name-char") (b* ((cst1 (pdf-cst-name-char-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x20-7E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-name-char-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-name-char-conc-rep-elem (tree-fix cst)) (pdf-cst-name-char-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-name-char-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-name-char-conc-rep-elem cst) (pdf-cst-name-char-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-plus-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "plus"))) (let ((__function__ 'pdf-cst-plus-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-plus-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-plus-conc-rep-elem (b* ((cst1 (pdf-cst-plus-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-rep-elem-match (implies (pdf-cst-matchp cst "plus") (b* ((cst1 (pdf-cst-plus-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x2B"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-plus-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-plus-conc-rep-elem (tree-fix cst)) (pdf-cst-plus-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-plus-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-plus-conc-rep-elem cst) (pdf-cst-plus-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-minus-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "minus"))) (let ((__function__ 'pdf-cst-minus-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-minus-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-minus-conc-rep-elem (b* ((cst1 (pdf-cst-minus-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-rep-elem-match (implies (pdf-cst-matchp cst "minus") (b* ((cst1 (pdf-cst-minus-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x2D"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-minus-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-minus-conc-rep-elem (tree-fix cst)) (pdf-cst-minus-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-minus-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-minus-conc-rep-elem cst) (pdf-cst-minus-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-slash-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "slash"))) (let ((__function__ 'pdf-cst-slash-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-slash-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-slash-conc-rep-elem (b* ((cst1 (pdf-cst-slash-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-rep-elem-match (implies (pdf-cst-matchp cst "slash") (b* ((cst1 (pdf-cst-slash-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x2F"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-slash-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-slash-conc-rep-elem (tree-fix cst)) (pdf-cst-slash-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-slash-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-slash-conc-rep-elem cst) (pdf-cst-slash-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-backslash-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "backslash"))) (let ((__function__ 'pdf-cst-backslash-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-backslash-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-backslash-conc-rep-elem (b* ((cst1 (pdf-cst-backslash-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-rep-elem-match (implies (pdf-cst-matchp cst "backslash") (b* ((cst1 (pdf-cst-backslash-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x5C"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-backslash-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-backslash-conc-rep-elem (tree-fix cst)) (pdf-cst-backslash-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-backslash-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-backslash-conc-rep-elem cst) (pdf-cst-backslash-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-zero-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "zero"))) (let ((__function__ 'pdf-cst-zero-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-zero-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-zero-conc-rep-elem (b* ((cst1 (pdf-cst-zero-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-rep-elem-match (implies (pdf-cst-matchp cst "zero") (b* ((cst1 (pdf-cst-zero-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x30"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-zero-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-zero-conc-rep-elem (tree-fix cst)) (pdf-cst-zero-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-zero-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-zero-conc-rep-elem cst) (pdf-cst-zero-conc-rep-elem cst-equiv))) :rule-classes :congruence)
Function:
(defun pdf-cst-period-conc-rep-elem (cst) (declare (xargs :guard (treep cst))) (declare (xargs :guard (pdf-cst-matchp cst "period"))) (let ((__function__ 'pdf-cst-period-conc-rep-elem)) (declare (ignorable __function__)) (tree-fix (nth 0 (pdf-cst-period-conc-rep cst)))))
Theorem:
(defthm treep-of-pdf-cst-period-conc-rep-elem (b* ((cst1 (pdf-cst-period-conc-rep-elem cst))) (treep cst1)) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-rep-elem-match (implies (pdf-cst-matchp cst "period") (b* ((cst1 (pdf-cst-period-conc-rep-elem cst))) (pdf-cst-matchp cst1 "%x2E"))) :rule-classes :rewrite)
Theorem:
(defthm pdf-cst-period-conc-rep-elem-of-tree-fix-cst (equal (pdf-cst-period-conc-rep-elem (tree-fix cst)) (pdf-cst-period-conc-rep-elem cst)))
Theorem:
(defthm pdf-cst-period-conc-rep-elem-tree-equiv-congruence-on-cst (implies (tree-equiv cst cst-equiv) (equal (pdf-cst-period-conc-rep-elem cst) (pdf-cst-period-conc-rep-elem cst-equiv))) :rule-classes :congruence)