diff --git a/KNOWN-GAPS.md b/KNOWN-GAPS.md
index 67d0cf2..a4b49dd 100644
--- a/KNOWN-GAPS.md
+++ b/KNOWN-GAPS.md
@@ -159,3 +159,24 @@ list is COMPLETE, not merely that the items are acceptable.
    ConsRec-equivalent acceptance; or (B) mechanize the signed-head +
    pin-store state machine and prove the refinement; or (C) keep the
    boundary and this scoped claim permanently.
+16. **The statement binding covers identity, not meaning** (added
+   2026-07-28 with `check.sh` Phase 3d). The coverage gate pins every
+   constant's name, kind and axiom cone, both directions; Phase 3d
+   additionally pins every constant's fully-elaborated TYPE and every
+   definition's fully-elaborated BODY, digest committed as
+   `AUDIT-MANIFEST.txt`. What that buys is that the corpus is the one
+   that was reviewed. What it does NOT buy: (a) whether those
+   statements say anything worth believing is a question a human
+   reading `STATEMENT-MAP.md` answers, not the button; (b) an author
+   who edits a definition and refreshes the digest in the same commit
+   passes every phase — the defence is that both changes are visible in
+   the diff at the pinned commit; (c) proof TERMS are deliberately not
+   bound, by proof irrelevance, so a proof rewritten to a different term
+   of the same statement and cone moves nothing.
+   Worth recording plainly, because it was measured rather than
+   reasoned: wrapping one branch of `pinAccept`'s body in `id (…)` is
+   definitionally equal, compiles, leaves name/kind/type/cone untouched,
+   and the coverage gate reports GREEN. Only the digest sees it. That is
+   the exact size of the gap Phase 3d closes, and
+   `selftest_statements.sh` case 1 replays it.
+
diff --git a/verification/AUDIT-MANIFEST.txt b/verification/AUDIT-MANIFEST.txt
new file mode 100644
index 0000000..37619e2
--- /dev/null
+++ b/verification/AUDIT-MANIFEST.txt
@@ -0,0 +1,266 @@
+STMT|LTLAcc.Bytes|def|type=Type
+STMT|LTLAcc.Bytes|def|value=List.{0} UInt8
+STMT|LTLAcc.ConsRec._unary._proof_1|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool), Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (LTLAcc.kbelow n) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b))) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))
+STMT|LTLAcc.ConsRec._unary._proof_2|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool), Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) → Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n)) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ (LTLAcc.kbelow n)) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n (LTLAcc.kbelow n)) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false))) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))
+STMT|LTLAcc.ConsRec._unary.eq_def|theorem|type=∀ (r : LTLAcc.Hash) (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r _x) (@PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) _x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => @ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Bool b Bool.true) (instDecidableEqBool b Bool.true) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash C) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)) (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b)))) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x (LTLAcc.hnode y s))) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false)))) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.hnode s x) (LTLAcc.hnode s y))))))
+STMT|LTLAcc.ConsRec._unary.induct|theorem|type=∀ (r : LTLAcc.Hash) (motive : (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → Prop) (case1 : ∀ (n : Nat), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.nil.{0} LTLAcc.Hash) Bool.true)))) (case2 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (h : Not (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C Bool.true)))) (case3 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Bool b Bool.true)) (h : @Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case4 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Bool b Bool.true)) (h : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case5 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case6 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.none.{0} LTLAcc.Hash) → motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case7 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : @LE.le.{0} Nat instLENat n₀ k), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → ∀ (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b)))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case8 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : @LE.le.{0} Nat instLENat n₀ k) (x y : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) → ∀ (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b)))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case9 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : Not (@LE.le.{0} Nat instLENat n₀ k)), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → ∀ (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false)))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (case10 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : Not (@LE.le.{0} Nat instLENat n₀ k)) (x y : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) → ∀ (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false)))), motive (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))) (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool), motive _x
+STMT|LTLAcc.ConsRec._unary|def|type=(r : LTLAcc.Hash) → (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)
+STMT|LTLAcc.ConsRec._unary|def|value=fun (r : LTLAcc.Hash) => @WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y _x → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y _x → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) _x (fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ n) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ n) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) n (fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n C)) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n C)) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) C (fun (C : List.{0} LTLAcc.Hash) (b : Bool) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : Bool) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b))) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (fun (h : @Eq.{1} Nat n₀ n) => @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Bool b Bool.true) (instDecidableEqBool b Bool.true) (fun (h : @Eq.{1} Bool b Bool.true) => @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash C) (fun (h : @Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) fun (h : Not (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash))) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (h : Not (@Eq.{1} Bool b Bool.true)) => @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (h : @Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)) (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)))) fun (h : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (h : Not (@Eq.{1} Nat n₀ n)) => @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (fun (h : Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) => LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (s : LTLAcc.Hash) => let k : Nat := LTLAcc.kbelow n; @dite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (fun (h_1 : @LE.le.{0} Nat instLENat n₀ k) => LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (a (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) b))) (LTLAcc.ConsRec._unary._proof_1 n₀ n C b h)) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x (LTLAcc.hnode y s))) fun (h_1 : Not (@LE.le.{0} Nat instLENat n₀ k)) => LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (a (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false))) (LTLAcc.ConsRec._unary._proof_2 n₀ n C b h h_1)) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.hnode s x) (LTLAcc.hnode s y))) a) a) a
+STMT|LTLAcc.ConsRec.eq_1|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ n C b r) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Bool b Bool.true) (instDecidableEqBool b Bool.true) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash C) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)) (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x (LTLAcc.hnode y s))) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.hnode s x) (LTLAcc.hnode s y))))))
+STMT|LTLAcc.ConsRec.eq_def|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ n C b r) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Bool b Bool.true) (instDecidableEqBool b Bool.true) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash C) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)) (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)))) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x (LTLAcc.hnode y s))) (LTLAcc.ConsRec.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) fun (x y : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.hnode s x) (LTLAcc.hnode s y))))))
+STMT|LTLAcc.ConsRec.induct|theorem|type=∀ (r : LTLAcc.Hash) (motive : (n₀ n : Nat) → (C : List.{0} LTLAcc.Hash) → (b : Bool) → Prop) (case1 : ∀ (n : Nat), motive n n (@List.nil.{0} LTLAcc.Hash) Bool.true) (case2 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (h : Not (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash))), motive n n C Bool.true) (case3 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Bool b Bool.true)) (h : @Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive n n C b) (case4 : ∀ (n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Bool b Bool.true)) (h : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), motive n n C b) (case5 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))), motive n₀ n C b) (case6 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.none.{0} LTLAcc.Hash) → motive n₀ n C b) (case7 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : @LE.le.{0} Nat instLENat n₀ k), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → ∀ (ih1 : motive n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b), motive n₀ n C b) (case8 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : @LE.le.{0} Nat instLENat n₀ k) (x y : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) → ∀ (ih1 : motive n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b), motive n₀ n C b) (case9 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : Not (@LE.le.{0} Nat instLENat n₀ k)), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → ∀ (ih1 : motive (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false), motive n₀ n C b) (case10 : ∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (h : Not (@Eq.{1} Nat n₀ n)) (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (x : LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash C) (@Option.some.{0} LTLAcc.Hash x) → have k : Nat := LTLAcc.kbelow n; ∀ (h : Not (@LE.le.{0} Nat instLENat n₀ k)) (x y : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) → ∀ (ih1 : motive (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false), motive n₀ n C b) (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool), motive n₀ n C b
+STMT|LTLAcc.ConsRec.match_1|def|type=(motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) → (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) → motive x
+STMT|LTLAcc.ConsRec.match_1|def|value=fun (motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) => @Option.casesOn.{u_1, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (fun (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) => motive x) x (h_1 Unit.unit) fun (val : Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) => @Prod.casesOn.{u_1, 0, 0} LTLAcc.Hash LTLAcc.Hash (fun (x : Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) => motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) x)) val fun (fst snd : LTLAcc.Hash) => h_2 fst snd
+STMT|LTLAcc.ConsRec|def|type=(n₀ n : Nat) → (C : List.{0} LTLAcc.Hash) → (b : Bool) → (r : LTLAcc.Hash) → Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)
+STMT|LTLAcc.ConsRec|def|value=fun (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash) => LTLAcc.ConsRec._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => Bool) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => Bool) C b)))
+STMT|LTLAcc.Hash|def|type=Type
+STMT|LTLAcc.Hash|def|value=@Subtype.{1} (List.{0} UInt8) fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))
+STMT|LTLAcc.IsCollision|def|type=(x y : List.{0} UInt8) → Prop
+STMT|LTLAcc.IsCollision|def|value=fun (x y : List.{0} UInt8) => And (@Ne.{1} (List.{0} UInt8) x y) (@Eq.{1} LTLAcc.Hash (LTLAcc.sha256 x) (LTLAcc.sha256 y))
+STMT|LTLAcc.MTH._proof_1|theorem|type=∀ (D : List.{0} LTLAcc.Bytes) (_h0 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) (_h1 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), @InvImage.{1, 1} (List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes x) (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) D
+STMT|LTLAcc.MTH._proof_2|theorem|type=∀ (D : List.{0} LTLAcc.Bytes) (_h0 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) (_h1 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), @InvImage.{1, 1} (List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes x) (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) D
+STMT|LTLAcc.MTH.eq_1|theorem|type=∀ (D : List.{0} LTLAcc.Bytes), @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) (@dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (fun (_h0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) => LTLAcc.sha256 (@List.nil.{0} UInt8)) fun (_h0 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) => @dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (_h1 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => LTLAcc.hleaf (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) fun (_h1 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => LTLAcc.hnode (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)))
+STMT|LTLAcc.MTH.eq_def|theorem|type=∀ (D : List.{0} LTLAcc.Bytes), @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) (@dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (fun (_h0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) => LTLAcc.sha256 (@List.nil.{0} UInt8)) fun (_h0 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) => @dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (_h1 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => LTLAcc.hleaf (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) fun (_h1 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => LTLAcc.hnode (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)))
+STMT|LTLAcc.MTH_single|theorem|type=∀ (d : LTLAcc.Bytes), @Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.cons.{0} LTLAcc.Bytes d (@List.nil.{0} LTLAcc.Bytes))) (LTLAcc.hleaf d)
+STMT|LTLAcc.MTH_split._proof_1_2|theorem|type=∀ (D : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) → False
+STMT|LTLAcc.MTH_split._proof_1_3|theorem|type=∀ (D : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) → False
+STMT|LTLAcc.MTH_split|theorem|type=∀ (D : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)), @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) (LTLAcc.hnode (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)))
+STMT|LTLAcc.MTH|def|type=(D : List.{0} LTLAcc.Bytes) → LTLAcc.Hash
+STMT|LTLAcc.MTH|def|value=@WellFounded.Nat.fix.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => LTLAcc.Hash) (fun (x : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes x) fun (D : List.{0} LTLAcc.Bytes) (a : (y : List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes x) y D → LTLAcc.Hash) => @dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (fun (_h0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) => LTLAcc.sha256 (@List.nil.{0} UInt8)) fun (_h0 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) => @dite.{1} LTLAcc.Hash (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (_h1 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => LTLAcc.hleaf (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) fun (_h1 : Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => LTLAcc.hnode (a (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (LTLAcc.MTH._proof_1 D _h0 _h1)) (a (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (LTLAcc.MTH._proof_2 D _h0 _h1))
+STMT|LTLAcc.Path._unary._proof_1|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)
+STMT|LTLAcc.Path._unary._proof_2|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)
+STMT|LTLAcc.Path._unary.eq_def|theorem|type=∀ (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes), @Eq.{1} (List.{0} LTLAcc.Hash) (LTLAcc.Path._unary _x) (@PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) _x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @ite.{1} (List.{0} LTLAcc.Hash) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@List.nil.{0} LTLAcc.Hash) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (List.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path._unary (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m (@List.take.{0} LTLAcc.Bytes k D))) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash))) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path._unary (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D))) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash)))))
+STMT|LTLAcc.Path._unary.induct|theorem|type=∀ (motive : (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) → Prop) (case1 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)) (case2 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : @LT.lt.{0} Nat instLTNat m k) (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m (@List.take.{0} LTLAcc.Bytes k D))), motive (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)) (case3 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : Not (@LT.lt.{0} Nat instLTNat m k)) (ih1 : motive (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D))), motive (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)) (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes), motive _x
+STMT|LTLAcc.Path._unary|def|type=(_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) → List.{0} LTLAcc.Hash
+STMT|LTLAcc.Path._unary|def|value=@WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y _x → List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y _x → List.{0} LTLAcc.Hash) → List.{0} LTLAcc.Hash) _x (fun (m : Nat) (D : List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => List.{0} LTLAcc.Bytes) => Nat) x fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D) → List.{0} LTLAcc.Hash) => @dite.{1} (List.{0} LTLAcc.Hash) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => @List.nil.{0} LTLAcc.Hash) fun (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => let k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @dite.{1} (List.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (fun (h_1 : @LT.lt.{0} Nat instLTNat m k) => @HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.Path._unary._proof_1 m D h)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash))) fun (h_1 : Not (@LT.lt.{0} Nat instLTNat m k)) => @HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.Path._unary._proof_2 m D h)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash))) a
+STMT|LTLAcc.Path.eq_1|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes), @Eq.{1} (List.{0} LTLAcc.Hash) (LTLAcc.Path m D) (@ite.{1} (List.{0} LTLAcc.Hash) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@List.nil.{0} LTLAcc.Hash) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (List.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path m (@List.take.{0} LTLAcc.Bytes k D)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash))) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash)))))
+STMT|LTLAcc.Path.eq_def|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes), @Eq.{1} (List.{0} LTLAcc.Hash) (LTLAcc.Path m D) (@ite.{1} (List.{0} LTLAcc.Hash) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@List.nil.{0} LTLAcc.Hash) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (List.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path m (@List.take.{0} LTLAcc.Bytes k D)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash))) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (LTLAcc.Path (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D)) (@List.cons.{0} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (@List.nil.{0} LTLAcc.Hash)))))
+STMT|LTLAcc.Path.induct|theorem|type=∀ (motive : (m : Nat) → (D : List.{0} LTLAcc.Bytes) → Prop) (case1 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive m D) (case2 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : @LT.lt.{0} Nat instLTNat m k) (ih1 : motive m (@List.take.{0} LTLAcc.Bytes k D)), motive m D) (case3 : ∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : Not (@LT.lt.{0} Nat instLTNat m k)) (ih1 : motive (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D)), motive m D) (m : Nat) (D : List.{0} LTLAcc.Bytes), motive m D
+STMT|LTLAcc.Path|def|type=(m : Nat) → (D : List.{0} LTLAcc.Bytes) → List.{0} LTLAcc.Hash
+STMT|LTLAcc.Path|def|value=fun (m : Nat) (D : List.{0} LTLAcc.Bytes) => LTLAcc.Path._unary (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => List.{0} LTLAcc.Bytes) m D)
+STMT|LTLAcc.Root._unary._proof_1|theorem|type=∀ (m n : Nat) (P : List.{0} LTLAcc.Hash), Not (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → Not (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (LTLAcc.kbelow n) (@List.dropLast.{0} LTLAcc.Hash P))) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) n P))
+STMT|LTLAcc.Root._unary._proof_2|theorem|type=∀ (m n : Nat) (P : List.{0} LTLAcc.Hash), Not (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow n)) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n (LTLAcc.kbelow n)) (@List.dropLast.{0} LTLAcc.Hash P))) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) n P))
+STMT|LTLAcc.Root._unary.eq_def|theorem|type=∀ (v : LTLAcc.Hash) (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root._unary v _x) (@PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) _x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => @ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash P) (@Option.some.{0} LTLAcc.Hash v) (@Option.none.{0} LTLAcc.Hash)) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@Option.none.{0} LTLAcc.Hash) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root._unary v (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) k (@List.dropLast.{0} LTLAcc.Hash P)))) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode x s)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root._unary v (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash P)))) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode s x)))))
+STMT|LTLAcc.Root._unary|def|type=(v : LTLAcc.Hash) → (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → Option.{0} LTLAcc.Hash
+STMT|LTLAcc.Root._unary|def|value=fun (v : LTLAcc.Hash) => @WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) y _x → Option.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => ((y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) y _x → Option.{0} LTLAcc.Hash) → Option.{0} LTLAcc.Hash) _x (fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m n) → Option.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => ((y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m n) → Option.{0} LTLAcc.Hash) → Option.{0} LTLAcc.Hash) n (fun (n : Nat) (P : List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) => Nat) n fun (n : Nat) (P : List.{0} LTLAcc.Hash) => n) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) n P)) → Option.{0} LTLAcc.Hash) => @dite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (h : @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => @dite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash P) (fun (h : @Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash)) => @Option.some.{0} LTLAcc.Hash v) fun (h : Not (@Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash))) => @Option.none.{0} LTLAcc.Hash) fun (h : Not (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => @dite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (fun (h : @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) => @Option.none.{0} LTLAcc.Hash) fun (h_1 : Not (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))))) => LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (s : LTLAcc.Hash) => let k : Nat := LTLAcc.kbelow n; @dite.{1} (Option.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (fun (h_2 : @LT.lt.{0} Nat instLTNat m k) => LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) k (@List.dropLast.{0} LTLAcc.Hash P))) (LTLAcc.Root._unary._proof_1 m n P h h_1)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode x s)) fun (h : Not (@LT.lt.{0} Nat instLTNat m k)) => LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash P))) (LTLAcc.Root._unary._proof_2 m n P h_1)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode s x)) a) a
+STMT|LTLAcc.Root.eq_1|theorem|type=∀ (v : LTLAcc.Hash) (m n : Nat) (P : List.{0} LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m n P) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash P) (@Option.some.{0} LTLAcc.Hash v) (@Option.none.{0} LTLAcc.Hash)) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@Option.none.{0} LTLAcc.Hash) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root v m k (@List.dropLast.{0} LTLAcc.Hash P)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode x s)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root v (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash P)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode s x)))))
+STMT|LTLAcc.Root.eq_def|theorem|type=∀ (v : LTLAcc.Hash) (m n : Nat) (P : List.{0} LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m n P) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} (List.{0} LTLAcc.Hash) P (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash P) (@Option.some.{0} LTLAcc.Hash v) (@Option.none.{0} LTLAcc.Hash)) (@ite.{1} (Option.{0} LTLAcc.Hash) (@Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (instDecidableEqNat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@Option.none.{0} LTLAcc.Hash) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} LTLAcc.Hash) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root v m k (@List.dropLast.{0} LTLAcc.Hash P)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode x s)) (LTLAcc.Root.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} LTLAcc.Hash) (LTLAcc.Root v (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash P)) (fun (_ : Unit) => @Option.none.{0} LTLAcc.Hash) fun (x : LTLAcc.Hash) => @Option.some.{0} LTLAcc.Hash (LTLAcc.hnode s x)))))
+STMT|LTLAcc.Root.match_1|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)) → motive x
+STMT|LTLAcc.Root.match_1|def|value=fun (motive : Option.{0} LTLAcc.Hash → Sort u_1) (x : Option.{0} LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)) => @Option.casesOn.{u_1, 0} LTLAcc.Hash (fun (x : Option.{0} LTLAcc.Hash) => motive x) x (h_1 Unit.unit) fun (val : LTLAcc.Hash) => h_2 val
+STMT|LTLAcc.Root_left._proof_1_1|theorem|type=∀ (m n : Nat) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) → False
+STMT|LTLAcc.Root_left._proof_1_2|theorem|type=∀ (m n : Nat) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) → False
+STMT|LTLAcc.Root_left|theorem|type=∀ (v : LTLAcc.Hash) (m n : Nat) (P : List.{0} LTLAcc.Hash) (s : LTLAcc.Hash) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n) (hm : @LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow n)), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m n (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) P (@List.cons.{0} LTLAcc.Hash s (@List.nil.{0} LTLAcc.Hash)))) (@Option.map.{0, 0} LTLAcc.Hash LTLAcc.Hash (fun (x : LTLAcc.Hash) => LTLAcc.hnode x s) (LTLAcc.Root v m (LTLAcc.kbelow n) P))
+STMT|LTLAcc.Root_one_cons|theorem|type=∀ (v : LTLAcc.Hash) (m : Nat) (p : LTLAcc.Hash) (q : List.{0} LTLAcc.Hash), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.cons.{0} LTLAcc.Hash p q)) (@Option.none.{0} LTLAcc.Hash)
+STMT|LTLAcc.Root_one|theorem|type=∀ (v : LTLAcc.Hash) (m : Nat), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.nil.{0} LTLAcc.Hash)) (@Option.some.{0} LTLAcc.Hash v)
+STMT|LTLAcc.Root_right._proof_1_1|theorem|type=∀ (m n : Nat) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) → False
+STMT|LTLAcc.Root_right._proof_1_2|theorem|type=∀ (m n : Nat) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @Eq.{1} Nat n (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) → False
+STMT|LTLAcc.Root_right|theorem|type=∀ (v : LTLAcc.Hash) (m n : Nat) (P : List.{0} LTLAcc.Hash) (s : LTLAcc.Hash) (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n) (hm : Not (@LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow n))), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root v m n (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) P (@List.cons.{0} LTLAcc.Hash s (@List.nil.{0} LTLAcc.Hash)))) (@Option.map.{0, 0} LTLAcc.Hash LTLAcc.Hash (fun (x : LTLAcc.Hash) => LTLAcc.hnode s x) (LTLAcc.Root v (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow n)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n (LTLAcc.kbelow n)) P))
+STMT|LTLAcc.Root|def|type=(v : LTLAcc.Hash) → (m n : Nat) → (P : List.{0} LTLAcc.Hash) → Option.{0} LTLAcc.Hash
+STMT|LTLAcc.Root|def|value=fun (v : LTLAcc.Hash) (m n : Nat) (P : List.{0} LTLAcc.Hash) => LTLAcc.Root._unary v (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => List.{0} LTLAcc.Hash) n P))
+STMT|LTLAcc.acceptCons_sound._proof_1_1|theorem|type=∀ (n₀ : Nat) (D₀ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (h0 : @Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → False
+STMT|LTLAcc.acceptCons_sound|theorem|type=∀ (n₀ : Nat) (C : List.{0} LTLAcc.Hash) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (hne : @Ne.{1} (List.{0} LTLAcc.Bytes) D₀ (@List.take.{0} LTLAcc.Bytes n₀ D₁)) (hacc : LTLAcc.acceptCons n₀ (@List.length.{0} LTLAcc.Bytes D₁) (LTLAcc.MTH D₀) (LTLAcc.MTH D₁) C), LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁)) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁))
+STMT|LTLAcc.acceptCons|def|type=(n₀ n₁ : Nat) → (r₀ r₁ : LTLAcc.Hash) → (C : List.{0} LTLAcc.Hash) → Prop
+STMT|LTLAcc.acceptCons|def|value=fun (n₀ n₁ : Nat) (r₀ r₁ : LTLAcc.Hash) (C : List.{0} LTLAcc.Hash) => Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ n₁ C Bool.true r₀) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r₀ r₁)))
+STMT|LTLAcc.acceptIncl_complete|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)), LTLAcc.acceptIncl (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)) m (@List.length.{0} LTLAcc.Bytes D) (LTLAcc.Path m D) (LTLAcc.MTH D)
+STMT|LTLAcc.acceptIncl_sound|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (d : LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) (hd : @Ne.{1} LTLAcc.Bytes d (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8))) (hacc : LTLAcc.acceptIncl d m (@List.length.{0} LTLAcc.Bytes D) P (LTLAcc.MTH D)), LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl m D d P)) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl m D d P))
+STMT|LTLAcc.acceptIncl|def|type=(d : LTLAcc.Bytes) → (m n : Nat) → (P : List.{0} LTLAcc.Hash) → (r : LTLAcc.Hash) → Prop
+STMT|LTLAcc.acceptIncl|def|value=fun (d : LTLAcc.Bytes) (m n : Nat) (P : List.{0} LTLAcc.Hash) (r : LTLAcc.Hash) => And (@LT.lt.{0} Nat instLTNat m n) (@Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root (LTLAcc.hleaf d) m n P) (@Option.some.{0} LTLAcc.Hash r))
+STMT|LTLAcc.consRecBinding._proof_1_10|theorem|type=∀ (n₀ n : Nat) (hle2 : @LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n)) (D₁ : List.{0} LTLAcc.Bytes) (htklen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow n) D₁)) (LTLAcc.kbelow n)), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat n₀ (LTLAcc.kbelow n)) n₀) → False
+STMT|LTLAcc.consRecBinding._proof_1_11|theorem|type=∀ (n₀ n : Nat) (hle2 : Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n))) (D₁ : List.{0} LTLAcc.Bytes), Not (@LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ (LTLAcc.kbelow n))) → False
+STMT|LTLAcc.consRecBinding._proof_1_12|theorem|type=∀ (n₀ n : Nat) (hrej : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (hle2 : Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n))) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow n) n), Not (@LE.le.{0} Nat instLENat (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ (LTLAcc.kbelow n)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n (LTLAcc.kbelow n))) → False
+STMT|LTLAcc.consRecBinding._proof_1_13|theorem|type=∀ (n₀ n : Nat) (hle2 : Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n))) (D₁ : List.{0} LTLAcc.Bytes) (hn0 : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) n₀) (hkp : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) (LTLAcc.kbelow n)), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n₀) → False
+STMT|LTLAcc.consRecBinding._proof_1_14|theorem|type=∀ (n₀ n : Nat) (hle2 : Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n))) (D₁ : List.{0} LTLAcc.Bytes), Not (@LT.lt.{0} Nat instLTNat (LTLAcc.kbelow n) n₀) → False
+STMT|LTLAcc.consRecBinding._proof_1_15|theorem|type=∀ (n₀ n : Nat) (hrej : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat n₀ n) n₀) → False
+STMT|LTLAcc.consRecBinding._proof_1_16|theorem|type=∀ (n₀ n : Nat) (D₁ : List.{0} LTLAcc.Bytes) (hn2 : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n₀) (htn0len : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes n₀ D₁)) n₀), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes n₀ D₁))) → False
+STMT|LTLAcc.consRecBinding._proof_1_17|theorem|type=∀ (n₀ n : Nat) (hle2 : Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n))) (D₁ : List.{0} LTLAcc.Bytes) (hkbn0 : @Eq.{1} Nat (LTLAcc.kbelow n₀) (LTLAcc.kbelow n)) (htn0len : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes n₀ D₁)) n₀), Not (@LE.le.{0} Nat instLENat (LTLAcc.kbelow n) n₀) → False
+STMT|LTLAcc.consRecBinding._proof_1_5|theorem|type=∀ (n₀ n : Nat) (hne : Not (@Eq.{1} Nat n₀ n)) (hrej : Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n) (hn0 : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) n₀) (hle : @LE.le.{0} Nat instLENat n₀ n), False
+STMT|LTLAcc.consRecBinding._proof_1_6|theorem|type=∀ (n₀ n : Nat) (hrej : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n) → False
+STMT|LTLAcc.consRecBinding._proof_1_7|theorem|type=∀ (n₀ n : Nat) (hrej : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D₁)) → False
+STMT|LTLAcc.consRecBinding._proof_1_8|theorem|type=∀ (n₀ n : Nat) (D₁ : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow n) n), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat (LTLAcc.kbelow n) n) (LTLAcc.kbelow n)) → False
+STMT|LTLAcc.consRecBinding.match_1|def|type=(motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) → (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) → motive x
+STMT|LTLAcc.consRecBinding.match_1|def|value=fun (motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) => @Option.casesOn.{u_1, 0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (fun (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => motive x) x (h_2 Unit.unit) fun (val : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => h_1 val
+STMT|LTLAcc.consRecBinding|theorem|type=∀ (r : LTLAcc.Hash) (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) (x y : LTLAcc.Hash), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₁) n → @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) n₀ → @LE.le.{0} Nat instLENat n₀ n → @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ n C b r) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) → @Eq.{1} LTLAcc.Hash y (LTLAcc.MTH D₁) → LTLAcc.consRecBinding.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => Prop) (LTLAcc.extractConsNode n₀ n C b r D₁) (fun (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) c) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) c)) fun (_ : Unit) => @Eq.{1} LTLAcc.Hash x (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes n₀ D₁))
+STMT|LTLAcc.consRec_base_false_eq._sparseCasesOn_1|def|type={α : Type u} → {motive : (t : List.{u} α) → Sort u_1} → (t : List.{u} α) → (cons : (head : α) → (tail : List.{u} α) → motive (@List.cons.{u} α head tail)) → ((h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{u} α t)) → motive t) → motive t
+STMT|LTLAcc.consRec_base_false_eq._sparseCasesOn_1|def|value=fun {α : Type u} {motive : (t : List.{u} α) → Sort u_1} (t : List.{u} α) (cons : (head : α) → (tail : List.{u} α) → motive (@List.cons.{u} α head tail)) => @List.rec.{u_1, u} α (fun (t : List.{u} α) => ((h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{u} α t)) → motive t) → motive t) (fun («else» : (h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{u} α (@List.nil.{u} α))) → motive (@List.nil.{u} α)) => «else» (@Nat.ne_of_beq_eq_false (Nat.land (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (Nat.shiftRight (nat_lit 2) (nat_lit 0))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@Eq.refl.{1} Bool Bool.false))) (fun (head : α) (tail : List.{u} α) (tail_ih : ((h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{u} α tail)) → motive tail) → motive tail) («else» : (h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{u} α (@List.cons.{u} α head tail))) → motive (@List.cons.{u} α head tail)) => cons head tail) t
+STMT|LTLAcc.consRec_base_false_eq._sparseCasesOn_2|def|type={α : Type u} → {motive : (t : List.{u} α) → Sort u_1} → (t : List.{u} α) → (nil : motive (@List.nil.{u} α)) → ((h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{u} α t)) → motive t) → motive t
+STMT|LTLAcc.consRec_base_false_eq._sparseCasesOn_2|def|value=fun {α : Type u} {motive : (t : List.{u} α) → Sort u_1} (t : List.{u} α) (nil : motive (@List.nil.{u} α)) => @List.rec.{u_1, u} α (fun (t : List.{u} α) => ((h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{u} α t)) → motive t) → motive t) (fun («else» : (h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{u} α (@List.nil.{u} α))) → motive (@List.nil.{u} α)) => nil) (fun (head : α) (tail : List.{u} α) (tail_ih : ((h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{u} α tail)) → motive tail) → motive tail) («else» : (h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{u} α (@List.cons.{u} α head tail))) → motive (@List.cons.{u} α head tail)) => «else» (@Nat.ne_of_beq_eq_false (Nat.land (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (Nat.shiftRight (nat_lit 1) (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@Eq.refl.{1} Bool Bool.false))) t
+STMT|LTLAcc.consRec_base_false_eq.match_1|def|type=(motive : List.{0} LTLAcc.Hash → Sort u_1) → (C : List.{0} LTLAcc.Hash) → (h_1 : (s : LTLAcc.Hash) → motive (@List.cons.{0} LTLAcc.Hash s (@List.nil.{0} LTLAcc.Hash))) → (h_2 : (x : List.{0} LTLAcc.Hash) → motive x) → motive C
+STMT|LTLAcc.consRec_base_false_eq.match_1|def|value=fun (motive : List.{0} LTLAcc.Hash → Sort u_1) (C : List.{0} LTLAcc.Hash) (h_1 : (s : LTLAcc.Hash) → motive (@List.cons.{0} LTLAcc.Hash s (@List.nil.{0} LTLAcc.Hash))) (h_2 : (x : List.{0} LTLAcc.Hash) → motive x) => @LTLAcc.consRec_base_false_eq._sparseCasesOn_1.{u_1, 0} LTLAcc.Hash (fun (x : List.{0} LTLAcc.Hash) => motive x) C (fun (head : LTLAcc.Hash) (tail : List.{0} LTLAcc.Hash) => @LTLAcc.consRec_base_false_eq._sparseCasesOn_2.{u_1, 0} LTLAcc.Hash (fun (x : List.{0} LTLAcc.Hash) => motive (@List.cons.{0} LTLAcc.Hash head x)) tail (h_1 head) fun (h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{0} LTLAcc.Hash tail)) => h_2 (@List.cons.{0} LTLAcc.Hash head tail)) fun (h : Nat.hasNotBit (nat_lit 2) (@List.ctorIdx.{0} LTLAcc.Hash C)) => h_2 C
+STMT|LTLAcc.consRec_base_false_eq|theorem|type=∀ (C : List.{0} LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} Nat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat (@List.length.{0} LTLAcc.Hash C) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)) (@List.getLastD.{0} LTLAcc.Hash C (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash)))) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (LTLAcc.consRec_base_false_eq.match_1.{1} (fun (C : List.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) C (fun (s : LTLAcc.Hash) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash s s)) fun (x : List.{0} LTLAcc.Hash) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))
+STMT|LTLAcc.consRec_base_true_eq.match_1|def|type=(motive : List.{0} LTLAcc.Hash → Sort u_1) → (C : List.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@List.nil.{0} LTLAcc.Hash)) → (h_2 : (x : List.{0} LTLAcc.Hash) → motive x) → motive C
+STMT|LTLAcc.consRec_base_true_eq.match_1|def|value=fun (motive : List.{0} LTLAcc.Hash → Sort u_1) (C : List.{0} LTLAcc.Hash) (h_1 : (a : Unit) → motive (@List.nil.{0} LTLAcc.Hash)) (h_2 : (x : List.{0} LTLAcc.Hash) → motive x) => @LTLAcc.consRec_base_false_eq._sparseCasesOn_2.{u_1, 0} LTLAcc.Hash (fun (x : List.{0} LTLAcc.Hash) => motive x) C (h_1 Unit.unit) fun (h : Nat.hasNotBit (nat_lit 1) (@List.ctorIdx.{0} LTLAcc.Hash C)) => h_2 C
+STMT|LTLAcc.consRec_base_true_eq|theorem|type=∀ (C : List.{0} LTLAcc.Hash) (r : LTLAcc.Hash), @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@ite.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (@Eq.{1} (List.{0} LTLAcc.Hash) C (@List.nil.{0} LTLAcc.Hash)) (@List.instDecidableEqNil.{0} LTLAcc.Hash C) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (LTLAcc.consRec_base_true_eq.match_1.{1} (fun (C : List.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) C (fun (_ : Unit) => @Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r)) fun (x : List.{0} LTLAcc.Hash) => @Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))
+STMT|LTLAcc.consRec_some_le._proof_1_1|theorem|type=∀ {n₀ n : Nat} (hgt : @LT.lt.{0} Nat instLTNat n n₀), @Eq.{1} Nat n₀ n → False
+STMT|LTLAcc.consRec_some_le|theorem|type=∀ {n₀ n : Nat} {C : List.{0} LTLAcc.Hash} {b : Bool} {r : LTLAcc.Hash} {p : Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash} (h : @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ n C b r) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) p)), @LE.le.{0} Nat instLENat n₀ n
+STMT|LTLAcc.domsep|theorem|type=∀ (d x y : LTLAcc.Bytes), @Ne.{1} (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} LTLAcc.Bytes LTLAcc.Bytes LTLAcc.Bytes (@instHAppendOfAppend.{0} LTLAcc.Bytes (@List.instAppend.{0} UInt8)) x y))
+STMT|LTLAcc.eq_dropLast_append_of_getLast?|theorem|type=∀ (l : List.{0} LTLAcc.Hash) (s : LTLAcc.Hash) (h : @Eq.{1} (Option.{0} LTLAcc.Hash) (@List.getLast?.{0} LTLAcc.Hash l) (@Option.some.{0} LTLAcc.Hash s)), @Eq.{1} (List.{0} LTLAcc.Hash) l (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (List.{0} LTLAcc.Hash) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Hash) (@List.instAppend.{0} LTLAcc.Hash)) (@List.dropLast.{0} LTLAcc.Hash l) (@List.cons.{0} LTLAcc.Hash s (@List.nil.{0} LTLAcc.Hash)))
+STMT|LTLAcc.exists_singleton_of_length_one|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (h : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes l) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), @Exists.{1} LTLAcc.Bytes fun (d : LTLAcc.Bytes) => @Eq.{1} (List.{0} LTLAcc.Bytes) l (@List.cons.{0} LTLAcc.Bytes d (@List.nil.{0} LTLAcc.Bytes))
+STMT|LTLAcc.extractCons.eq_1|theorem|type=∀ (n₀ : Nat) (C : List.{0} LTLAcc.Hash) (D₀ D₁ : List.{0} LTLAcc.Bytes), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractCons n₀ C D₀ D₁) (LTLAcc.extractCons.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractConsNode n₀ (@List.length.{0} LTLAcc.Bytes D₁) C Bool.true (LTLAcc.MTH D₀) D₁) (fun (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => c) fun (_ : Unit) => LTLAcc.extractMTH D₀ (@List.take.{0} LTLAcc.Bytes n₀ D₁))
+STMT|LTLAcc.extractCons.match_1|def|type=(motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) → (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) → motive x
+STMT|LTLAcc.extractCons.match_1|def|value=fun (motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) => @Option.casesOn.{u_1, 0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (fun (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => motive x) x (h_2 Unit.unit) fun (val : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => h_1 val
+STMT|LTLAcc.extractConsNode._unary._proof_1|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (D₁ : List.{0} LTLAcc.Bytes), Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (LTLAcc.kbelow n) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow n) D₁))))) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b D₁))))
+STMT|LTLAcc.extractConsNode._unary._proof_2|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (D₁ : List.{0} LTLAcc.Bytes), Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) → Not (@LE.le.{0} Nat instLENat n₀ (LTLAcc.kbelow n)) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ (LTLAcc.kbelow n)) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n (LTLAcc.kbelow n)) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) Bool.false (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow n) D₁))))) (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b D₁))))
+STMT|LTLAcc.extractConsNode._unary.eq_def|theorem|type=∀ (r : LTLAcc.Hash) (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes), @Eq.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode._unary r _x) (@PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) _x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b (@List.take.{0} LTLAcc.Bytes k D₁)))))) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y') (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) Bool.false (@List.drop.{0} LTLAcc.Bytes k D₁)))))) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y'))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))))))
+STMT|LTLAcc.extractConsNode._unary|def|type=(r : LTLAcc.Hash) → (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))
+STMT|LTLAcc.extractConsNode._unary|def|value=fun (r : LTLAcc.Hash) => @WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y _x → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y _x → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) _x (fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ n) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ n) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) n (fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n C)) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n C)) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) C (fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C b))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C b))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) b (fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} Nat fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) x fun (n₀ : Nat) (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (n : @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) n fun (n : Nat) (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (C : @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) C fun (C : List.{0} LTLAcc.Hash) (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) (fun (b : @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) => Nat) b fun (b : Bool) (D₁ : List.{0} LTLAcc.Bytes) => n) y (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b D₁)))) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => @dite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (fun (h : @Eq.{1} Nat n₀ n) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (h : Not (@Eq.{1} Nat n₀ n)) => @dite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (fun (h : Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (h : Not (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))))) => LTLAcc.extractConsNode.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (s : LTLAcc.Hash) => let k : Nat := LTLAcc.kbelow n; @dite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (fun (h_1 : @LE.le.{0} Nat instLENat n₀ k) => let y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @dite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (fun (h_2 : And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) => a (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) k (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b (@List.take.{0} LTLAcc.Bytes k D₁))))) (LTLAcc.extractConsNode._unary._proof_1 n₀ n C b D₁ h)) fun (h : Not (And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))))) => @Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y') (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))))))) fun (h_1 : Not (@LE.le.{0} Nat instLENat n₀ k)) => let y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @dite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (fun (h_2 : And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) => a (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) (@List.dropLast.{0} LTLAcc.Hash C) (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) Bool.false (@List.drop.{0} LTLAcc.Bytes k D₁))))) (LTLAcc.extractConsNode._unary._proof_2 n₀ n C b D₁ h h_1)) fun (h : Not (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))))) => @Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y'))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))))))) a) a) a) a
+STMT|LTLAcc.extractConsNode.eq_1|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash) (D₁ : List.{0} LTLAcc.Bytes), @Eq.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode n₀ n C b r D₁) (@ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r (@List.take.{0} LTLAcc.Bytes k D₁)) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y') (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r (@List.drop.{0} LTLAcc.Bytes k D₁)) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y'))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))))))
+STMT|LTLAcc.extractConsNode.eq_def|theorem|type=∀ (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash) (D₁ : List.{0} LTLAcc.Bytes), @Eq.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode n₀ n C b r D₁) (@ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@Eq.{1} Nat n₀ n) (instDecidableEqNat n₀ n) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (Or (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@instDecidableOr (@GT.gt.{0} Nat instLTNat n₀ n) (Or (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (Nat.decLt n n₀) (@instDecidableOr (@Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (instDecidableEqNat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (LTLAcc.extractConsNode.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@List.getLast?.{0} LTLAcc.Hash C) (fun (_ : Unit) => @Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) fun (s : LTLAcc.Hash) => have k : Nat := LTLAcc.kbelow n; @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (@LE.le.{0} Nat instLENat n₀ k) (Nat.decLe n₀ k) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode n₀ k (@List.dropLast.{0} LTLAcc.Hash C) b r (@List.take.{0} LTLAcc.Bytes k D₁)) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y') (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))) (have y' : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (@Option.map.{0, 0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) LTLAcc.Hash (@Prod.snd.{0, 0} LTLAcc.Hash LTLAcc.Hash) (LTLAcc.ConsRec (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Eq.{1} LTLAcc.Hash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (LTLAcc.instDecidableEqHash y' (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))) (LTLAcc.extractConsNode (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n k) (@List.dropLast.{0} LTLAcc.Hash C) Bool.false r (@List.drop.{0} LTLAcc.Bytes k D₁)) (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y'))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D₁))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D₁)))))))))))
+STMT|LTLAcc.extractConsNode.match_1|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) → motive x
+STMT|LTLAcc.extractConsNode.match_1|def|value=fun (motive : Option.{0} LTLAcc.Hash → Sort u_1) (x : Option.{0} LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) => @Option.casesOn.{u_1, 0} LTLAcc.Hash (fun (x : Option.{0} LTLAcc.Hash) => motive x) x (h_1 Unit.unit) fun (val : LTLAcc.Hash) => h_2 val
+STMT|LTLAcc.extractConsNode|def|type=(n₀ n : Nat) → (C : List.{0} LTLAcc.Hash) → (b : Bool) → (r : LTLAcc.Hash) → (D₁ : List.{0} LTLAcc.Bytes) → Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))
+STMT|LTLAcc.extractConsNode|def|value=fun (n₀ n : Nat) (C : List.{0} LTLAcc.Hash) (b : Bool) (r : LTLAcc.Hash) (D₁ : List.{0} LTLAcc.Bytes) => LTLAcc.extractConsNode._unary r (@PSigma.mk.{1, 1} Nat (fun (n₀ : Nat) => @PSigma.{1, 1} Nat fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n₀ (@PSigma.mk.{1, 1} Nat (fun (n : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Hash) fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) n (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Hash) (fun (C : List.{0} LTLAcc.Hash) => @PSigma.{1, 1} Bool fun (b : Bool) => List.{0} LTLAcc.Bytes) C (@PSigma.mk.{1, 1} Bool (fun (b : Bool) => List.{0} LTLAcc.Bytes) b D₁))))
+STMT|LTLAcc.extractCons_correct._proof_1_2|theorem|type=∀ (n₀ : Nat) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hle : @LE.le.{0} Nat instLENat n₀ (@List.length.{0} LTLAcc.Bytes D₁)), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat n₀ (@List.length.{0} LTLAcc.Bytes D₁)) n₀) → False
+STMT|LTLAcc.extractCons_correct._proof_1_3|theorem|type=∀ (n₀ : Nat) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (htklen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes n₀ D₁)) n₀), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes n₀ D₁))) → False
+STMT|LTLAcc.extractCons_correct_paper._proof_1_1|theorem|type=∀ (n₀ : Nat) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (h0 : @Eq.{1} Nat n₀ (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → False
+STMT|LTLAcc.extractCons_correct_paper|theorem|type=∀ (n₀ : Nat) (C : List.{0} LTLAcc.Hash) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (hle : @LE.le.{0} Nat instLENat n₀ (@List.length.{0} LTLAcc.Bytes D₁)) (hne : @Ne.{1} (List.{0} LTLAcc.Bytes) D₀ (@List.take.{0} LTLAcc.Bytes n₀ D₁)) (hacc : @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ (@List.length.{0} LTLAcc.Bytes D₁) C Bool.true (LTLAcc.MTH D₀)) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.MTH D₀) (LTLAcc.MTH D₁)))), LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁)) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁))
+STMT|LTLAcc.extractCons_correct|theorem|type=∀ (n₀ : Nat) (C : List.{0} LTLAcc.Hash) (D₀ D₁ : List.{0} LTLAcc.Bytes) (hlen0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D₀) n₀) (hn0 : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) n₀) (hle : @LE.le.{0} Nat instLENat n₀ (@List.length.{0} LTLAcc.Bytes D₁)) (hne : @Ne.{1} (List.{0} LTLAcc.Bytes) D₀ (@List.take.{0} LTLAcc.Bytes n₀ D₁)) (hacc : @Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n₀ (@List.length.{0} LTLAcc.Bytes D₁) C Bool.true (LTLAcc.MTH D₀)) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash (LTLAcc.MTH D₀) (LTLAcc.MTH D₁)))), LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁)) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons n₀ C D₀ D₁))
+STMT|LTLAcc.extractCons_nonvacuous._proof_1_2|theorem|type=Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractCons_nonvacuous|theorem|type=Not (LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.nil.{0} LTLAcc.Hash) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractCons (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.nil.{0} LTLAcc.Hash) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))))
+STMT|LTLAcc.extractCons|def|type=(n₀ : Nat) → (C : List.{0} LTLAcc.Hash) → (D₀ D₁ : List.{0} LTLAcc.Bytes) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.extractCons|def|value=fun (n₀ : Nat) (C : List.{0} LTLAcc.Hash) (D₀ D₁ : List.{0} LTLAcc.Bytes) => LTLAcc.extractCons.match_1.{1} (fun (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractConsNode n₀ (@List.length.{0} LTLAcc.Bytes D₁) C Bool.true (LTLAcc.MTH D₀) D₁) (fun (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => c) fun (_ : Unit) => LTLAcc.extractMTH D₀ (@List.take.{0} LTLAcc.Bytes n₀ D₁)
+STMT|LTLAcc.extractIncl._unary._proof_1|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (@List.dropLast.{0} LTLAcc.Hash P))) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) D P))
+STMT|LTLAcc.extractIncl._unary._proof_2|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (@List.dropLast.{0} LTLAcc.Hash P))) (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) D P))
+STMT|LTLAcc.extractIncl._unary.eq_def|theorem|type=∀ (d : LTLAcc.Bytes) (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractIncl._unary d _x) (@PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) _x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); LTLAcc.extractIncl.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.nil.{0} UInt8) (@List.nil.{0} UInt8)) fun (s : LTLAcc.Hash) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) m k (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl._unary d (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.take.{0} LTLAcc.Bytes k D) (@List.dropLast.{0} LTLAcc.Hash P)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))))) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) k) (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl._unary d (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.drop.{0} LTLAcc.Bytes k D) (@List.dropLast.{0} LTLAcc.Hash P)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))))))))
+STMT|LTLAcc.extractIncl._unary|def|type=(d : LTLAcc.Bytes) → (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.extractIncl._unary|def|value=fun (d : LTLAcc.Bytes) => @WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) y _x → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => ((y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) y _x → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) _x (fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m D) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => ((y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m D) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) D (fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) (a : (y : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) → @InvImage.{1, 1} (@PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (_x : @PSigma.{1, 1} Nat fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) x fun (m : Nat) (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (fun (D : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) => Nat) D fun (D : List.{0} LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => @List.length.{0} LTLAcc.Bytes D) y (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) D P)) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)))) fun (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => let k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); LTLAcc.extractIncl.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.nil.{0} UInt8) (@List.nil.{0} UInt8)) fun (s : LTLAcc.Hash) => @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (fun (h_1 : @LT.lt.{0} Nat instLTNat m k) => let child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) m k (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (fun (h_2 : And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) => a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.take.{0} LTLAcc.Bytes k D) (@List.dropLast.{0} LTLAcc.Hash P))) (LTLAcc.extractIncl._unary._proof_1 m D P h)) fun (h : Not (And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))))) fun (h_1 : Not (@LT.lt.{0} Nat instLTNat m k)) => let child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) k) (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (fun (h_2 : And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) => a (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) (@List.drop.{0} LTLAcc.Bytes k D) (@List.dropLast.{0} LTLAcc.Hash P))) (LTLAcc.extractIncl._unary._proof_2 m D P h)) fun (h : Not (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))))) a) a
+STMT|LTLAcc.extractIncl.eq_1|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (d : LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractIncl m D d P) (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); LTLAcc.extractIncl.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.nil.{0} UInt8) (@List.nil.{0} UInt8)) fun (s : LTLAcc.Hash) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) m k (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl m (@List.take.{0} LTLAcc.Bytes k D) d (@List.dropLast.{0} LTLAcc.Hash P)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))))) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) k) (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D) d (@List.dropLast.{0} LTLAcc.Hash P)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))))))))
+STMT|LTLAcc.extractIncl.eq_def|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (d : LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractIncl m D d P) (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); LTLAcc.extractIncl.match_1.{1} (fun (x : Option.{0} LTLAcc.Hash) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@List.getLast?.{0} LTLAcc.Hash P) (fun (_ : Unit) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.nil.{0} UInt8) (@List.nil.{0} UInt8)) fun (s : LTLAcc.Hash) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LT.lt.{0} Nat instLTNat m k) (Nat.decLt m k) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) m k (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl m (@List.take.{0} LTLAcc.Bytes k D) d (@List.dropLast.{0} LTLAcc.Hash P)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))))) (have child : LTLAcc.Hash := @Option.getD.{0} LTLAcc.Hash (LTLAcc.Root (LTLAcc.hleaf d) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) k) (@List.dropLast.{0} LTLAcc.Hash P)) (@Inhabited.default.{1} LTLAcc.Hash LTLAcc.instInhabitedHash); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Eq.{1} LTLAcc.Hash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash s (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (LTLAcc.instDecidableEqHash child (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))) (LTLAcc.extractIncl (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m k) (@List.drop.{0} LTLAcc.Bytes k D) d (@List.dropLast.{0} LTLAcc.Hash P)) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) s) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) child))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)))))))))
+STMT|LTLAcc.extractIncl.match_1|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) → motive x
+STMT|LTLAcc.extractIncl.match_1|def|value=fun (motive : Option.{0} LTLAcc.Hash → Sort u_1) (x : Option.{0} LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) => @Option.casesOn.{u_1, 0} LTLAcc.Hash (fun (x : Option.{0} LTLAcc.Hash) => motive x) x (h_1 Unit.unit) fun (val : LTLAcc.Hash) => h_2 val
+STMT|LTLAcc.extractIncl_correct._proof_1_1|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hle : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_3|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_4|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_5|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_6|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_7|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hmk : @LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (htklen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))), Not (@LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_8|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hmk : Not (@LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)) (hdplen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))), Not (@LT.lt.{0} Nat instLTNat (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (@List.length.{0} LTLAcc.Bytes (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D))) → False
+STMT|LTLAcc.extractIncl_correct._proof_1_9|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hmk : Not (@LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))), Not (@Eq.{1} Nat (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))) m) → False
+STMT|LTLAcc.extractIncl_correct|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (d : LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash), @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D) → @Ne.{1} LTLAcc.Bytes d (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8)) → @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root (LTLAcc.hleaf d) m (@List.length.{0} LTLAcc.Bytes D) P) (@Option.some.{0} LTLAcc.Hash (LTLAcc.MTH D)) → LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl m D d P)) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl m D d P))
+STMT|LTLAcc.extractIncl_nonvacuous._proof_1_2|theorem|type=Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractIncl_nonvacuous|theorem|type=Not (LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Hash))) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractIncl (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Hash))))
+STMT|LTLAcc.extractIncl|def|type=(m : Nat) → (D : List.{0} LTLAcc.Bytes) → (d : LTLAcc.Bytes) → (P : List.{0} LTLAcc.Hash) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.extractIncl|def|value=fun (m : Nat) (D : List.{0} LTLAcc.Bytes) (d : LTLAcc.Bytes) (P : List.{0} LTLAcc.Hash) => LTLAcc.extractIncl._unary d (@PSigma.mk.{1, 1} Nat (fun (m : Nat) => @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) m (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Hash) D P))
+STMT|LTLAcc.extractMTH._unary._proof_1|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D')) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')
+STMT|LTLAcc.extractMTH._unary._proof_2|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes), Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → @InvImage.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D) (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D')) (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')
+STMT|LTLAcc.extractMTH._unary.eq_def|theorem|type=∀ (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractMTH._unary _x) (@PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) _x fun (D D' : List.{0} LTLAcc.Bytes) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D' (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableNot (@Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableEqList.{0} LTLAcc.Bytes (fun (a b : LTLAcc.Bytes) => @instDecidableEqList.{0} UInt8 instDecidableEqUInt8 a b) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.extractMTH._unary (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.extractMTH._unary (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D')))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))))))
+STMT|LTLAcc.extractMTH._unary.induct|theorem|type=∀ (motive : (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) → Prop) (case1 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')) (case2 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (h : @Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (ih1 : motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))), motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')) (case3 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (h : Not (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (ih1 : motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D'))), motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')) (case4 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : Not (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))), motive (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')) (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes), motive _x
+STMT|LTLAcc.extractMTH._unary|def|type=(_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.extractMTH._unary|def|value=@WellFounded.Nat.fix.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y _x → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => ((y : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y _x → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) _x (fun (D D' : List.{0} LTLAcc.Bytes) (a : (y : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) → @InvImage.{1, 1} (@PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => @PSigma.casesOn.{1, 1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (fun (_x : @PSigma.{1, 1} (List.{0} LTLAcc.Bytes) fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) => Nat) x fun (D D' : List.{0} LTLAcc.Bytes) => @List.length.{0} LTLAcc.Bytes D) y (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D') → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) => @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (fun (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D' (@List.nil.{0} UInt8)))) fun (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) => let k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (fun (h_1 : And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) => @dite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableNot (@Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableEqList.{0} LTLAcc.Bytes (fun (a b : LTLAcc.Bytes) => @instDecidableEqList.{0} UInt8 instDecidableEqUInt8 a b) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (fun (h_2 : @Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) => a (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (LTLAcc.extractMTH._unary._proof_1 D D' h)) fun (h_2 : Not (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) => a (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D')) (LTLAcc.extractMTH._unary._proof_2 D D' h)) fun (h : Not (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))) => @Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))))) a
+STMT|LTLAcc.extractMTH.eq_1|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractMTH D D') (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D' (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableNot (@Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableEqList.{0} LTLAcc.Bytes (fun (a b : LTLAcc.Bytes) => @instDecidableEqList.{0} UInt8 instDecidableEqUInt8 a b) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.extractMTH (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (LTLAcc.extractMTH (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D'))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))))))
+STMT|LTLAcc.extractMTH.eq_def|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.extractMTH D D') (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (Nat.decLe (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D (@List.nil.{0} UInt8))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) (@List.headD.{0} LTLAcc.Bytes D' (@List.nil.{0} UInt8)))) (have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@instDecidableAnd (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.instDecidableEqHash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableNot (@Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (@instDecidableEqList.{0} LTLAcc.Bytes (fun (a b : LTLAcc.Bytes) => @instDecidableEqList.{0} UInt8 instDecidableEqUInt8 a b) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (LTLAcc.extractMTH (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (LTLAcc.extractMTH (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D'))) (@Prod.mk.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D))))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))))))
+STMT|LTLAcc.extractMTH.induct|theorem|type=∀ (motive : (D D' : List.{0} LTLAcc.Bytes) → Prop) (case1 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), motive D D') (case2 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (h : @Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')) (ih1 : motive (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D')), motive D D') (case3 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D')))) (h : Not (@Ne.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k D) (@List.take.{0} LTLAcc.Bytes k D'))) (ih1 : motive (@List.drop.{0} LTLAcc.Bytes k D) (@List.drop.{0} LTLAcc.Bytes k D')), motive D D') (case4 : ∀ (D D' : List.{0} LTLAcc.Bytes) (h : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), have k : Nat := LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D); ∀ (h : Not (And (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.take.{0} LTLAcc.Bytes k D'))) (@Eq.{1} LTLAcc.Hash (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D)) (LTLAcc.MTH (@List.drop.{0} LTLAcc.Bytes k D'))))), motive D D') (D D' : List.{0} LTLAcc.Bytes), motive D D'
+STMT|LTLAcc.extractMTH_correct._proof_1_10|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D')) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_4|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')) (h0 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D') (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_5|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hle : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')) (hp : @GT.gt.{0} Nat instLTNat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_6|theorem|type=∀ (D' : List.{0} LTLAcc.Bytes) (a : LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.cons.{0} LTLAcc.Bytes a (@List.nil.{0} LTLAcc.Bytes))) (@List.length.{0} LTLAcc.Bytes D')) (hd1 : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.cons.{0} LTLAcc.Bytes a (@List.nil.{0} LTLAcc.Bytes))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D') (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_7|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)) (@Min.min.{0} Nat instMinNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D'))) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_8|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')), Not (@Eq.{1} Nat (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D') (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))) → False
+STMT|LTLAcc.extractMTH_correct._proof_1_9|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (hlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D')), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)) → False
+STMT|LTLAcc.extractMTH_correct|theorem|type=∀ (D D' : List.{0} LTLAcc.Bytes), @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@List.length.{0} LTLAcc.Bytes D') → @Ne.{1} (List.{0} LTLAcc.Bytes) D D' → @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) (LTLAcc.MTH D') → LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractMTH D D')) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractMTH D D'))
+STMT|LTLAcc.extractMTH_nonvacuous._proof_1_2|theorem|type=Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.extractMTH_nonvacuous|theorem|type=Not (LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractMTH (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.extractMTH (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))))
+STMT|LTLAcc.extractMTH|def|type=(D D' : List.{0} LTLAcc.Bytes) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.extractMTH|def|value=fun (D D' : List.{0} LTLAcc.Bytes) => LTLAcc.extractMTH._unary (@PSigma.mk.{1, 1} (List.{0} LTLAcc.Bytes) (fun (D : List.{0} LTLAcc.Bytes) => List.{0} LTLAcc.Bytes) D D')
+STMT|LTLAcc.fork_distinct|theorem|type=∀ (n : Nat) (r r' : LTLAcc.Hash) (D D' : List.{0} LTLAcc.Bytes) (hDlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) n) (hD'len : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D') n) (hDr : @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) r) (hD'r : @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D') r') (hrne : @Ne.{1} LTLAcc.Hash r r'), @Ne.{1} (List.{0} LTLAcc.Bytes) D D'
+STMT|LTLAcc.getD_drop._proof_1_1|theorem|type=∀ (i k' : Nat), Not (@Eq.{1} Nat (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) k' (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) i) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) k' i) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) → False
+STMT|LTLAcc.getD_drop|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (k i : Nat), @Eq.{1} LTLAcc.Bytes (@List.getD.{0} LTLAcc.Bytes (@List.drop.{0} LTLAcc.Bytes k l) i (@List.nil.{0} UInt8)) (@List.getD.{0} LTLAcc.Bytes l (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) k i) (@List.nil.{0} UInt8))
+STMT|LTLAcc.getD_take._proof_1_1|theorem|type=∀ (m : Nat) (h : @LT.lt.{0} Nat instLTNat m (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))), False
+STMT|LTLAcc.getD_take._proof_1_2|theorem|type=∀ (k' m' : Nat) (h : @LT.lt.{0} Nat instLTNat (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) m' (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) k' (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), Not (@LT.lt.{0} Nat instLTNat m' k') → False
+STMT|LTLAcc.getD_take|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (k m : Nat) (h : @LT.lt.{0} Nat instLTNat m k), @Eq.{1} LTLAcc.Bytes (@List.getD.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes k l) m (@List.nil.{0} UInt8)) (@List.getD.{0} LTLAcc.Bytes l m (@List.nil.{0} UInt8))
+STMT|LTLAcc.hleaf|def|type=(d : LTLAcc.Bytes) → LTLAcc.Hash
+STMT|LTLAcc.hleaf|def|value=fun (d : LTLAcc.Bytes) => LTLAcc.sha256 (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))) d)
+STMT|LTLAcc.hnode_preimage_inj|theorem|type=∀ {x y X Y : LTLAcc.Hash} (h : @Eq.{1} (List.{0} UInt8) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) x) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y))) (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) X) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) Y)))), And (@Eq.{1} LTLAcc.Hash x X) (@Eq.{1} LTLAcc.Hash y Y)
+STMT|LTLAcc.hnode|def|type=(x y : LTLAcc.Hash) → LTLAcc.Hash
+STMT|LTLAcc.hnode|def|value=fun (x y : LTLAcc.Hash) => LTLAcc.sha256 (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 1) (@UInt8.instOfNat (nat_lit 1))) (@HAppend.hAppend.{0, 0, 0} (List.{0} UInt8) (List.{0} UInt8) (List.{0} UInt8) (@instHAppendOfAppend.{0} (List.{0} UInt8) (@List.instAppend.{0} UInt8)) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) x) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) y)))
+STMT|LTLAcc.incl_complete._proof_1_3|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hle : @LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)), Not (@Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.incl_complete._proof_1_5|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hgt : Not (@LE.le.{0} Nat instLENat (@List.length.{0} LTLAcc.Bytes D) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@List.length.{0} LTLAcc.Bytes D)) → False
+STMT|LTLAcc.incl_complete._proof_1_6|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) → False
+STMT|LTLAcc.incl_complete._proof_1_7|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hmk : @LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (htklen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))), Not (@LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes (@List.take.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D))) → False
+STMT|LTLAcc.incl_complete._proof_1_8|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hmk : Not (@LT.lt.{0} Nat instLTNat m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))), Not (@Eq.{1} Nat (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))) m) → False
+STMT|LTLAcc.incl_complete._proof_1_9|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)) (hkl : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@List.length.{0} LTLAcc.Bytes D)) (hidx : @Eq.{1} Nat (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))) m) (hdplen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D)) (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) (@List.length.{0} LTLAcc.Bytes D) (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)))), Not (@LT.lt.{0} Nat instLTNat (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) m (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D))) (@List.length.{0} LTLAcc.Bytes (@List.drop.{0} LTLAcc.Bytes (LTLAcc.kbelow (@List.length.{0} LTLAcc.Bytes D)) D))) → False
+STMT|LTLAcc.incl_complete|theorem|type=∀ (m : Nat) (D : List.{0} LTLAcc.Bytes) (hm : @LT.lt.{0} Nat instLTNat m (@List.length.{0} LTLAcc.Bytes D)), @Eq.{1} (Option.{0} LTLAcc.Hash) (LTLAcc.Root (LTLAcc.hleaf (@List.getD.{0} LTLAcc.Bytes D m (@List.nil.{0} UInt8))) m (@List.length.{0} LTLAcc.Bytes D) (LTLAcc.Path m D)) (@Option.some.{0} LTLAcc.Hash (LTLAcc.MTH D))
+STMT|LTLAcc.instDecidableEqHash._proof_1|theorem|type=∀ (a b : LTLAcc.Hash), Iff (@Eq.{1} (List.{0} UInt8) (@Subtype.val.{1} (List.{0} UInt8) (fun (x : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 x) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) a) (@Subtype.val.{1} (List.{0} UInt8) (fun (x : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 x) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) b)) (@Eq.{1} (@Subtype.{1} (List.{0} UInt8) fun (x : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 x) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) a b)
+STMT|LTLAcc.instDecidableEqHash|def|type=DecidableEq.{1} LTLAcc.Hash
+STMT|LTLAcc.instDecidableEqHash|def|value=fun (a b : LTLAcc.Hash) => @decidable_of_iff (@Eq.{1} LTLAcc.Hash a b) (@Eq.{1} (List.{0} UInt8) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) a) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) b)) (LTLAcc.instDecidableEqHash._proof_1 a b) (@instDecidableEqList.{0} UInt8 instDecidableEqUInt8 (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) a) (@Subtype.val.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) b))
+STMT|LTLAcc.instInhabitedHash._proof_1|theorem|type=@Eq.{1} Nat (@List.length.{0} UInt8 (@List.replicate.{0} UInt8 (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0))))) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))
+STMT|LTLAcc.instInhabitedHash|def|type=Inhabited.{1} LTLAcc.Hash
+STMT|LTLAcc.instInhabitedHash|def|value=@Inhabited.mk.{1} LTLAcc.Hash (@Subtype.mk.{1} (List.{0} UInt8) (fun (l : List.{0} UInt8) => @Eq.{1} Nat (@List.length.{0} UInt8 l) (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (@List.replicate.{0} UInt8 (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (@OfNat.ofNat.{0} UInt8 (nat_lit 0) (@UInt8.instOfNat (nat_lit 0)))) LTLAcc.instInhabitedHash._proof_1)
+STMT|LTLAcc.kbelow._proof_1|theorem|type=∀ (n : Nat), Not (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) → @InvImage.{1, 1} Nat Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : Nat) => x) (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) n
+STMT|LTLAcc.kbelow._unsafe_rec|def|type=(n : Nat) → Nat
+STMT|LTLAcc.kbelow._unsafe_rec|def|value=fun (n : Nat) => @ite.{1} Nat (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow._unsafe_rec (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))))
+STMT|LTLAcc.kbelow.eq_1|theorem|type=∀ (n : Nat), @Eq.{1} Nat (LTLAcc.kbelow n) (@ite.{1} Nat (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))))))
+STMT|LTLAcc.kbelow.eq_def|theorem|type=∀ (n : Nat), @Eq.{1} Nat (LTLAcc.kbelow n) (@ite.{1} Nat (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))))))
+STMT|LTLAcc.kbelow.induct|theorem|type=∀ (motive : (n : Nat) → Prop) (case1 : ∀ (x : Nat) (h : @LE.le.{0} Nat instLENat x (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))), motive x) (case2 : ∀ (x : Nat) (h : Not (@LE.le.{0} Nat instLENat x (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) (ih1 : motive (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) x (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))), motive x) (n : Nat), motive n
+STMT|LTLAcc.kbelow_eq_of_pow2_between._proof_1_1|theorem|type=∀ {p m : Nat} (j : Nat) (hp : @Eq.{1} Nat p (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)) (h1 : @LT.lt.{0} Nat instLTNat p m) (this : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) p), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) m) → False
+STMT|LTLAcc.kbelow_eq_of_pow2_between._proof_1_2|theorem|type=∀ {p m : Nat} (j : Nat) (hp : @Eq.{1} Nat p (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)) (h2 : @LE.le.{0} Nat instLENat m (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) p)) (a : Nat), Not (@LE.le.{0} Nat instLENat m (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) → False
+STMT|LTLAcc.kbelow_eq_of_pow2_between._proof_1_3|theorem|type=∀ {p m : Nat} (j a : Nat) (hle : @LE.le.{0} Nat instLENat m (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) a))), Not (@LE.le.{0} Nat instLENat m (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) a) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) → False
+STMT|LTLAcc.kbelow_eq_of_pow2_between._proof_1_4|theorem|type=∀ {p m : Nat} (j : Nat) (hp : @Eq.{1} Nat p (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)) (h1 : @LT.lt.{0} Nat instLTNat p m) (a : Nat), Not (@LT.lt.{0} Nat instLTNat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j) m) → False
+STMT|LTLAcc.kbelow_eq_of_pow2_between|theorem|type=∀ {p m : Nat} (j : Nat) (hp : @Eq.{1} Nat p (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)) (h1 : @LT.lt.{0} Nat instLTNat p m) (h2 : @LE.le.{0} Nat instLENat m (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) p)), @Eq.{1} Nat (LTLAcc.kbelow m) p
+STMT|LTLAcc.kbelow_lt._proof_1_3|theorem|type=∀ (n : Nat) (hle : @LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), Not (@LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) n) → False
+STMT|LTLAcc.kbelow_lt._proof_1_4|theorem|type=∀ (n : Nat) (hgt : Not (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) → False
+STMT|LTLAcc.kbelow_lt._proof_1_5|theorem|type=∀ (n : Nat) (this : @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))), Not (@LT.lt.{0} Nat instLTNat (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))))) n) → False
+STMT|LTLAcc.kbelow_lt|theorem|type=∀ (n : Nat) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @LT.lt.{0} Nat instLTNat (LTLAcc.kbelow n) n
+STMT|LTLAcc.kbelow_pos|theorem|type=∀ (n : Nat), @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) (LTLAcc.kbelow n)
+STMT|LTLAcc.kbelow_pow2|theorem|type=∀ (n : Nat), @Exists.{1} Nat fun (j : Nat) => @Eq.{1} Nat (LTLAcc.kbelow n) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)
+STMT|LTLAcc.kbelow_prefix_eq._proof_1_1|theorem|type=∀ {k n n₀ : Nat} (hk : @Eq.{1} Nat k (LTLAcc.kbelow n)) (hhi : @LE.le.{0} Nat instLENat n₀ n) (j : Nat) (hj : @Eq.{1} Nat k (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)) (hle : @LE.le.{0} Nat instLENat n (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) k)), Not (@LE.le.{0} Nat instLENat n₀ (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) k)) → False
+STMT|LTLAcc.kbelow_prefix_eq|theorem|type=∀ {k n n₀ : Nat} (hn : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n) (hk : @Eq.{1} Nat k (LTLAcc.kbelow n)) (hlo : @LT.lt.{0} Nat instLTNat k n₀) (hhi : @LE.le.{0} Nat instLENat n₀ n), @Eq.{1} Nat (LTLAcc.kbelow n₀) k
+STMT|LTLAcc.kbelow|def|type=(n : Nat) → Nat
+STMT|LTLAcc.kbelow|def|value=@WellFounded.Nat.fix.{1, 1} Nat (fun (n : Nat) => Nat) (fun (x : Nat) => x) fun (n : Nat) (a : (y : Nat) → @InvImage.{1, 1} Nat Nat (fun (x1 x2 : Nat) => @LT.lt.{0} Nat instLTNat x1 x2) (fun (x : Nat) => x) y n → Nat) => @dite.{1} Nat (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (Nat.decLe n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (fun (h : @LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) => @OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) fun (h : Not (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) => @HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (a (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (LTLAcc.kbelow._proof_1 n h))
+STMT|LTLAcc.le_two_kbelow._proof_1_3|theorem|type=∀ (n : Nat) (hgt : Not (@LE.le.{0} Nat instLENat n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))), Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))) → False
+STMT|LTLAcc.le_two_kbelow._proof_1_4|theorem|type=∀ (n : Nat) (this : @LE.le.{0} Nat instLENat (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))) (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))))), Not (@LE.le.{0} Nat instLENat n (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow (@HDiv.hDiv.{0, 0, 0} Nat Nat Nat (@instHDiv.{0} Nat Nat.instDiv) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))))))) → False
+STMT|LTLAcc.le_two_kbelow|theorem|type=∀ (n : Nat) (h : @LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) n), @LE.le.{0} Nat instLENat n (@HMul.hMul.{0, 0, 0} Nat Nat Nat (@instHMul.{0} Nat instMulNat) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (LTLAcc.kbelow n))
+STMT|LTLAcc.pinAccept_monotone._proof_1_1|theorem|type=∀ (n n' : Nat) (he : @Eq.{1} Nat n' n), Not (@LE.le.{0} Nat instLENat n n') → False
+STMT|LTLAcc.pinAccept_monotone._proof_1_2|theorem|type=∀ (n n' : Nat) (hl : Not (@LT.lt.{0} Nat instLTNat n' n)), Not (@LE.le.{0} Nat instLENat n n') → False
+STMT|LTLAcc.pinAccept_monotone|theorem|type=∀ (n : Nat) (r : LTLAcc.Hash) (n' : Nat) (r' : LTLAcc.Hash) (C : List.{0} LTLAcc.Hash) (h : LTLAcc.pinAccept n r n' r' C), @LE.le.{0} Nat instLENat n n'
+STMT|LTLAcc.pinAccept|def|type=(n : Nat) → (r : LTLAcc.Hash) → (n' : Nat) → (r' : LTLAcc.Hash) → (C : List.{0} LTLAcc.Hash) → Prop
+STMT|LTLAcc.pinAccept|def|value=fun (n : Nat) (r : LTLAcc.Hash) (n' : Nat) (r' : LTLAcc.Hash) (C : List.{0} LTLAcc.Hash) => @ite.{1} Prop (@Eq.{1} Nat n' n) (instDecidableEqNat n' n) (@Eq.{1} LTLAcc.Hash r' r) (@ite.{1} Prop (@LT.lt.{0} Nat instLTNat n' n) (Nat.decLt n' n) False (@Eq.{1} (Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) (LTLAcc.ConsRec n n' C Bool.true r) (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash r r'))))
+STMT|LTLAcc.pinExtract.eq_1|theorem|type=∀ (n n' : Nat) (C : List.{0} LTLAcc.Hash) (D D' : List.{0} LTLAcc.Bytes), @Eq.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (LTLAcc.pinExtract n n' C D D') (@ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Eq.{1} Nat n' n) (instDecidableEqNat n' n) (LTLAcc.extractMTH D D') (LTLAcc.extractCons n C D D'))
+STMT|LTLAcc.pinExtract|def|type=(n n' : Nat) → (C : List.{0} LTLAcc.Hash) → (D D' : List.{0} LTLAcc.Bytes) → Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)
+STMT|LTLAcc.pinExtract|def|value=fun (n n' : Nat) (C : List.{0} LTLAcc.Hash) (D D' : List.{0} LTLAcc.Bytes) => @ite.{1} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (@Eq.{1} Nat n' n) (instDecidableEqNat n' n) (LTLAcc.extractMTH D D') (LTLAcc.extractCons n C D D')
+STMT|LTLAcc.pin_prefix_correct._proof_1_2|theorem|type=∀ (n n' : Nat) (D D' : List.{0} LTLAcc.Bytes) (hD'len : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D') n') (hl : Not (@LT.lt.{0} Nat instLTNat n' n)), Not (@LE.le.{0} Nat instLENat n (@List.length.{0} LTLAcc.Bytes D')) → False
+STMT|LTLAcc.pin_prefix_correct|theorem|type=∀ (n n' : Nat) (r r' : LTLAcc.Hash) (C : List.{0} LTLAcc.Hash) (D D' : List.{0} LTLAcc.Bytes) (hstep : LTLAcc.pinAccept n r n' r' C) (hDlen : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D) n) (hDr : @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D) r) (hD'len : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes D') n') (hD'r : @Eq.{1} LTLAcc.Hash (LTLAcc.MTH D') r') (hn0 : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0))) n) (hne : @Ne.{1} (List.{0} LTLAcc.Bytes) D (@List.take.{0} LTLAcc.Bytes n D')), LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.pinExtract n n' C D D')) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.pinExtract n n' C D D'))
+STMT|LTLAcc.pin_prefix_nonvacuous._proof_1_2|theorem|type=Not (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))) → False
+STMT|LTLAcc.pin_prefix_nonvacuous|theorem|type=Not (LTLAcc.IsCollision (@Prod.fst.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.pinExtract (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.nil.{0} LTLAcc.Hash) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))) (@Prod.snd.{0, 0} (List.{0} UInt8) (List.{0} UInt8) (LTLAcc.pinExtract (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) (@List.nil.{0} LTLAcc.Hash) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)) (@List.cons.{0} LTLAcc.Bytes (@List.cons.{0} UInt8 (@OfNat.ofNat.{0} UInt8 (nat_lit 7) (@UInt8.instOfNat (nat_lit 7))) (@List.nil.{0} UInt8)) (@List.nil.{0} LTLAcc.Bytes)))))
+STMT|LTLAcc.pow2_exp_unique._proof_1_1|theorem|type=∀ {a j m : Nat}, Not (@GT.gt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))) → False
+STMT|LTLAcc.pow2_exp_unique._proof_1_2|theorem|type=∀ {a j m : Nat} (ha2 : @LE.le.{0} Nat instLENat m (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) a (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (hj : @LT.lt.{0} Nat instLTNat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j) m) (hle : @LE.le.{0} Nat instLENat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) a (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j)), False
+STMT|LTLAcc.pow2_exp_unique._proof_1_3|theorem|type=∀ {a j m : Nat} (ha : @LT.lt.{0} Nat instLTNat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) a) m) (hj2 : @LE.le.{0} Nat instLENat m (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) j (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (hle : @LE.le.{0} Nat instLENat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) j (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))) (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) a)), False
+STMT|LTLAcc.pow2_exp_unique|theorem|type=∀ {a j m : Nat} (ha : @LT.lt.{0} Nat instLTNat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) a) m) (ha2 : @LE.le.{0} Nat instLENat m (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) a (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))) (hj : @LT.lt.{0} Nat instLTNat (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) j) m) (hj2 : @LE.le.{0} Nat instLENat m (@HPow.hPow.{0, 0, 0} Nat Nat Nat (@instHPow.{0, 0} Nat Nat (@instPowNat.{0} Nat instNatPowNat)) (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))) (@HAdd.hAdd.{0, 0, 0} Nat Nat Nat (@instHAdd.{0} Nat instAddNat) j (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))))), @Eq.{1} Nat a j
+STMT|LTLAcc.sha256|axiom|type=List.{0} UInt8 → LTLAcc.Hash
+STMT|LTLAcc.take_all|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (n : Nat) (h : @Eq.{1} Nat (@List.length.{0} LTLAcc.Bytes l) n), @Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes n l) l
+STMT|LTLAcc.take_append_drop|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (k : Nat), @Eq.{1} (List.{0} LTLAcc.Bytes) (@HAppend.hAppend.{0, 0, 0} (List.{0} LTLAcc.Bytes) (List.{0} LTLAcc.Bytes) (List.{0} LTLAcc.Bytes) (@instHAppendOfAppend.{0} (List.{0} LTLAcc.Bytes) (@List.instAppend.{0} LTLAcc.Bytes)) (@List.take.{0} LTLAcc.Bytes k l) (@List.drop.{0} LTLAcc.Bytes k l)) l
+STMT|LTLAcc.take_drop_prefix|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (k n₀ : Nat), @Eq.{1} (List.{0} LTLAcc.Bytes) (@List.drop.{0} LTLAcc.Bytes k (@List.take.{0} LTLAcc.Bytes n₀ l)) (@List.take.{0} LTLAcc.Bytes (@HSub.hSub.{0, 0, 0} Nat Nat Nat (@instHSub.{0} Nat instSubNat) n₀ k) (@List.drop.{0} LTLAcc.Bytes k l))
+STMT|LTLAcc.take_take_le._proof_1_1|theorem|type=∀ (k n₀ : Nat) (h : @LE.le.{0} Nat instLENat k n₀), Not (@Eq.{1} Nat (@Min.min.{0} Nat instMinNat k n₀) k) → False
+STMT|LTLAcc.take_take_le|theorem|type=∀ (l : List.{0} LTLAcc.Bytes) (k n₀ : Nat) (h : @LE.le.{0} Nat instLENat k n₀), @Eq.{1} (List.{0} LTLAcc.Bytes) (@List.take.{0} LTLAcc.Bytes k (@List.take.{0} LTLAcc.Bytes n₀ l)) (@List.take.{0} LTLAcc.Bytes k l)
+STMT|_private.Proofs.Basic.0.LTLAcc.ConsRec.match_1.eq_1|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))), @Eq.{u_1} (motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (LTLAcc.ConsRec.match_1.{u_1} motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Basic.0.LTLAcc.ConsRec.match_1.eq_2|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) (x y : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))), @Eq.{u_1} (motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) (LTLAcc.ConsRec.match_1.{u_1} motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) h_1 h_2) (h_2 x y)
+STMT|_private.Proofs.Basic.0.LTLAcc.ConsRec.match_1.splitter|def|type=(motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) → (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) → motive x
+STMT|_private.Proofs.Basic.0.LTLAcc.ConsRec.match_1.splitter|def|value=LTLAcc.ConsRec.match_1.{u_1}
+STMT|_private.Proofs.Basic.0.LTLAcc.Root.match_1.eq_1|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)), @Eq.{u_1} (motive (@Option.none.{0} LTLAcc.Hash)) (LTLAcc.Root.match_1.{u_1} motive (@Option.none.{0} LTLAcc.Hash) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Basic.0.LTLAcc.Root.match_1.eq_2|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (x : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)), @Eq.{u_1} (motive (@Option.some.{0} LTLAcc.Hash x)) (LTLAcc.Root.match_1.{u_1} motive (@Option.some.{0} LTLAcc.Hash x) h_1 h_2) (h_2 x)
+STMT|_private.Proofs.Basic.0.LTLAcc.Root.match_1.splitter|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)) → motive x
+STMT|_private.Proofs.Basic.0.LTLAcc.Root.match_1.splitter|def|value=LTLAcc.Root.match_1.{u_1}
+STMT|_private.Proofs.Basic.0.PSigma.casesOn._arg_pusher|theorem|type=∀ {α : Sort u} {β : α → Sort v} {motive : (t : @PSigma.{u, v} α β) → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : (t : @PSigma.{u, v} α β) → (x : α_1) → Prop) (t : @PSigma.{u, v} α β) (mk : (fst : α) → (snd : β fst) → ((y : α_1) → (h : rel (@PSigma.mk.{u, v} α β fst snd) y) → β_1 y) → motive (@PSigma.mk.{u, v} α β fst snd)), @Eq.{u_1} (motive t) (@PSigma.casesOn.{imax (imax u✝ v✝) u_1, u, v} α β (fun (t : @PSigma.{u, v} α β) => ((y : α_1) → (h : rel t y) → β_1 y) → motive t) t mk fun (y : α_1) (h : rel t y) => f y) (@PSigma.casesOn.{u_1, u, v} α β motive t fun (fst : α) (snd : β fst) => mk fst snd fun (y : α_1) (h : rel (@PSigma.mk.{u, v} α β fst snd) y) => f y)
+STMT|_private.Proofs.Binding3.0.LTLAcc.ConsRec.match_1.eq_1|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))), @Eq.{u_1} (motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (LTLAcc.ConsRec.match_1.{u_1} motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Binding3.0.LTLAcc.ConsRec.match_1.eq_2|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) (x y : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))), @Eq.{u_1} (motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) (LTLAcc.ConsRec.match_1.{u_1} motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y)) h_1 h_2) (h_2 x y)
+STMT|_private.Proofs.Binding3.0.LTLAcc.ConsRec.match_1.splitter|def|type=(motive : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash)) → (h_1 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash))) → (h_2 : (x y : LTLAcc.Hash) → motive (@Option.some.{0} (Prod.{0, 0} LTLAcc.Hash LTLAcc.Hash) (@Prod.mk.{0, 0} LTLAcc.Hash LTLAcc.Hash x y))) → motive x
+STMT|_private.Proofs.Binding3.0.LTLAcc.ConsRec.match_1.splitter|def|value=LTLAcc.ConsRec.match_1.{u_1}
+STMT|_private.Proofs.Binding3.0.LTLAcc.Root.match_1.eq_1|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)), @Eq.{u_1} (motive (@Option.none.{0} LTLAcc.Hash)) (LTLAcc.Root.match_1.{u_1} motive (@Option.none.{0} LTLAcc.Hash) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Binding3.0.LTLAcc.Root.match_1.eq_2|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (x : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)), @Eq.{u_1} (motive (@Option.some.{0} LTLAcc.Hash x)) (LTLAcc.Root.match_1.{u_1} motive (@Option.some.{0} LTLAcc.Hash x) h_1 h_2) (h_2 x)
+STMT|_private.Proofs.Binding3.0.LTLAcc.Root.match_1.splitter|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (x : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash x)) → motive x
+STMT|_private.Proofs.Binding3.0.LTLAcc.Root.match_1.splitter|def|value=LTLAcc.Root.match_1.{u_1}
+STMT|_private.Proofs.Binding3.0.LTLAcc.consRecBinding.match_1.eq_1|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))), @Eq.{u_1} (motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) (LTLAcc.consRecBinding.match_1.{u_1} motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c) h_1 h_2) (h_1 c)
+STMT|_private.Proofs.Binding3.0.LTLAcc.consRecBinding.match_1.eq_2|theorem|type=∀ (motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))), @Eq.{u_1} (motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) (LTLAcc.consRecBinding.match_1.{u_1} motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) h_1 h_2) (h_2 Unit.unit)
+STMT|_private.Proofs.Binding3.0.LTLAcc.consRecBinding.match_1.splitter|def|type=(motive : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → Sort u_1) → (x : Option.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8))) → (h_1 : (c : Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) → motive (@Option.some.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)) c)) → (h_2 : (a : Unit) → motive (@Option.none.{0} (Prod.{0, 0} (List.{0} UInt8) (List.{0} UInt8)))) → motive x
+STMT|_private.Proofs.Binding3.0.LTLAcc.consRecBinding.match_1.splitter|def|value=LTLAcc.consRecBinding.match_1.{u_1}
+STMT|_private.Proofs.Completeness.0.PSigma.casesOn._arg_pusher|theorem|type=∀ {α : Sort u} {β : α → Sort v} {motive : (t : @PSigma.{u, v} α β) → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : (t : @PSigma.{u, v} α β) → (x : α_1) → Prop) (t : @PSigma.{u, v} α β) (mk : (fst : α) → (snd : β fst) → ((y : α_1) → (h : rel (@PSigma.mk.{u, v} α β fst snd) y) → β_1 y) → motive (@PSigma.mk.{u, v} α β fst snd)), @Eq.{u_1} (motive t) (@PSigma.casesOn.{imax (imax u✝ v✝) u_1, u, v} α β (fun (t : @PSigma.{u, v} α β) => ((y : α_1) → (h : rel t y) → β_1 y) → motive t) t mk fun (y : α_1) (h : rel t y) => f y) (@PSigma.casesOn.{u_1, u, v} α β motive t fun (fst : α) (snd : β fst) => mk fst snd fun (y : α_1) (h : rel (@PSigma.mk.{u, v} α β fst snd) y) => f y)
+STMT|_private.Proofs.Consistency.0.LTLAcc.extractConsNode.match_1.eq_1|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)), @Eq.{u_1} (motive (@Option.none.{0} LTLAcc.Hash)) (LTLAcc.extractConsNode.match_1.{u_1} motive (@Option.none.{0} LTLAcc.Hash) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Consistency.0.LTLAcc.extractConsNode.match_1.eq_2|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (s : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)), @Eq.{u_1} (motive (@Option.some.{0} LTLAcc.Hash s)) (LTLAcc.extractConsNode.match_1.{u_1} motive (@Option.some.{0} LTLAcc.Hash s) h_1 h_2) (h_2 s)
+STMT|_private.Proofs.Consistency.0.LTLAcc.extractConsNode.match_1.splitter|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) → motive x
+STMT|_private.Proofs.Consistency.0.LTLAcc.extractConsNode.match_1.splitter|def|value=LTLAcc.extractConsNode.match_1.{u_1}
+STMT|_private.Proofs.Consistency.0.PSigma.casesOn._arg_pusher|theorem|type=∀ {α : Sort u} {β : α → Sort v} {motive : (t : @PSigma.{u, v} α β) → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : (t : @PSigma.{u, v} α β) → (x : α_1) → Prop) (t : @PSigma.{u, v} α β) (mk : (fst : α) → (snd : β fst) → ((y : α_1) → (h : rel (@PSigma.mk.{u, v} α β fst snd) y) → β_1 y) → motive (@PSigma.mk.{u, v} α β fst snd)), @Eq.{u_1} (motive t) (@PSigma.casesOn.{imax (imax u✝ v✝) u_1, u, v} α β (fun (t : @PSigma.{u, v} α β) => ((y : α_1) → (h : rel t y) → β_1 y) → motive t) t mk fun (y : α_1) (h : rel t y) => f y) (@PSigma.casesOn.{u_1, u, v} α β motive t fun (fst : α) (snd : β fst) => mk fst snd fun (y : α_1) (h : rel (@PSigma.mk.{u, v} α β fst snd) y) => f y)
+STMT|_private.Proofs.Descent.0.PSigma.casesOn._arg_pusher|theorem|type=∀ {α : Sort u} {β : α → Sort v} {motive : (t : @PSigma.{u, v} α β) → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : (t : @PSigma.{u, v} α β) → (x : α_1) → Prop) (t : @PSigma.{u, v} α β) (mk : (fst : α) → (snd : β fst) → ((y : α_1) → (h : rel (@PSigma.mk.{u, v} α β fst snd) y) → β_1 y) → motive (@PSigma.mk.{u, v} α β fst snd)), @Eq.{u_1} (motive t) (@PSigma.casesOn.{imax (imax u✝ v✝) u_1, u, v} α β (fun (t : @PSigma.{u, v} α β) => ((y : α_1) → (h : rel t y) → β_1 y) → motive t) t mk fun (y : α_1) (h : rel t y) => f y) (@PSigma.casesOn.{u_1, u, v} α β motive t fun (fst : α) (snd : β fst) => mk fst snd fun (y : α_1) (h : rel (@PSigma.mk.{u, v} α β fst snd) y) => f y)
+STMT|_private.Proofs.Extract.0.LTLAcc.extractIncl.match_1.eq_1|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)), @Eq.{u_1} (motive (@Option.none.{0} LTLAcc.Hash)) (LTLAcc.extractIncl.match_1.{u_1} motive (@Option.none.{0} LTLAcc.Hash) h_1 h_2) (h_1 Unit.unit)
+STMT|_private.Proofs.Extract.0.LTLAcc.extractIncl.match_1.eq_2|theorem|type=∀ (motive : Option.{0} LTLAcc.Hash → Sort u_1) (s : LTLAcc.Hash) (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)), @Eq.{u_1} (motive (@Option.some.{0} LTLAcc.Hash s)) (LTLAcc.extractIncl.match_1.{u_1} motive (@Option.some.{0} LTLAcc.Hash s) h_1 h_2) (h_2 s)
+STMT|_private.Proofs.Extract.0.LTLAcc.extractIncl.match_1.splitter|def|type=(motive : Option.{0} LTLAcc.Hash → Sort u_1) → (x : Option.{0} LTLAcc.Hash) → (h_1 : (a : Unit) → motive (@Option.none.{0} LTLAcc.Hash)) → (h_2 : (s : LTLAcc.Hash) → motive (@Option.some.{0} LTLAcc.Hash s)) → motive x
+STMT|_private.Proofs.Extract.0.LTLAcc.extractIncl.match_1.splitter|def|value=LTLAcc.extractIncl.match_1.{u_1}
+STMT|_private.Proofs.Extract.0.PSigma.casesOn._arg_pusher|theorem|type=∀ {α : Sort u} {β : α → Sort v} {motive : (t : @PSigma.{u, v} α β) → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : (t : @PSigma.{u, v} α β) → (x : α_1) → Prop) (t : @PSigma.{u, v} α β) (mk : (fst : α) → (snd : β fst) → ((y : α_1) → (h : rel (@PSigma.mk.{u, v} α β fst snd) y) → β_1 y) → motive (@PSigma.mk.{u, v} α β fst snd)), @Eq.{u_1} (motive t) (@PSigma.casesOn.{imax (imax u✝ v✝) u_1, u, v} α β (fun (t : @PSigma.{u, v} α β) => ((y : α_1) → (h : rel t y) → β_1 y) → motive t) t mk fun (y : α_1) (h : rel t y) => f y) (@PSigma.casesOn.{u_1, u, v} α β motive t fun (fst : α) (snd : β fst) => mk fst snd fun (y : α_1) (h : rel (@PSigma.mk.{u, v} α β fst snd) y) => f y)
diff --git a/verification/Proofs/Inventory.lean b/verification/Proofs/Inventory.lean
index b920003..2ca827d 100644
--- a/verification/Proofs/Inventory.lean
+++ b/verification/Proofs/Inventory.lean
@@ -95,7 +95,23 @@ def axiomCone (env : Environment) (root : Name) : Array Name := Id.run do
           stack := stack ++ v.getUsedConstants
   return (axioms.qsort (fun a b => a.toString < b.toString))
 
-#eval show CoreM Unit from do
+/-- Whitespace-canonical: every whitespace run collapses to one space, so the
+    pretty-printer's line wrapping cannot perturb the digest. -/
+def normWs (s : String) : String :=
+  (s.foldl (fun (acc : String × Bool) c =>
+      let c := if c.isWhitespace then ' ' else c
+      if c == ' ' then (if acc.2 then acc else (acc.1.push ' ', true))
+      else (acc.1.push c, false))
+    ("", true)).1
+
+/-- Fully-explicit (`pp.all`) rendering, whitespace-canonicalized. Implicit
+    arguments, instances and universe levels are all made visible, so two
+    statements that merely LOOK alike cannot share a rendering. -/
+def ppAll (e : Expr) : MetaM String := do
+  let fmt ← withOptions (fun o => o.setBool `pp.all true) (Meta.ppExpr e)
+  return normWs fmt.pretty
+
+#eval show MetaM Unit from do
   let env ← getEnv
   -- Resolve every corpus module to its index; a miss is a hard error.
   let mut idxs : Array Nat := #[]
@@ -104,6 +120,17 @@ def axiomCone (env : Environment) (root : Name) : Array Name := Id.run do
     | some i => idxs := idxs.push i
     | none   => throwError "INVENTORY ERROR: corpus module {m} is not imported"
   let mut lines : Array String := #[]
+  -- STATEMENT SURFACE (P1-a). The INV lines above record what each constant
+  -- IS and what it RESTS ON. They do not record what it SAYS: a theorem gutted
+  -- to a tautology keeps its name, its kind and its axiom cone, and a `def`
+  -- redefined to BE the thing it was meant to specify keeps all three too,
+  -- while the certificate stated against it silently becomes vacuous. So every
+  -- constant additionally contributes its fully-elaborated TYPE, and every
+  -- definition its fully-elaborated BODY. Proof terms are NOT emitted: by
+  -- proof irrelevance a theorem's content is its statement, and its term is
+  -- both enormous and irrelevant to what is being claimed.
+  let mut stmts : Array String := #[]
+  let mut nTypes := 0
   for (n, ci) in env.constants.toList do
     if let some i := env.getModuleIdxFor? n then
       if idxs.contains i then
@@ -115,9 +142,25 @@ def axiomCone (env : Environment) (root : Name) : Array Name := Id.run do
           throwError "INVENTORY ERROR: cone divergence on {n}: walker={cone} core={coreCone}"
         let coneStr := ",".intercalate (cone.toList.map (·.toString))
         lines := lines.push s!"INV|{n}|{kindOf ci}|{coneStr}"
+        stmts := stmts.push s!"STMT|{n}|{kindOf ci}|type={← ppAll ci.type}"
+        nTypes := nTypes + 1
+        match ci with
+        | .defnInfo v => stmts := stmts.push s!"STMT|{n}|{kindOf ci}|value={← ppAll v.value}"
+        | _           => pure ()
   let sorted := lines.qsort (· < ·)
   for l in sorted do
     IO.println l
   IO.println s!"INV-COUNT|{sorted.size}"
+  -- FAIL CLOSED: the statement surface must cover the inventory exactly. If
+  -- these ever diverge, some constant is inventoried but unbound — which is
+  -- precisely the gap this section exists to close.
+  let sortedStmts := stmts.qsort (· < ·)
+  unless nTypes == sorted.size do
+    throwError "INVENTORY ERROR: {sorted.size} constants inventoried but {nTypes} carry a statement"
+  IO.println "STMT-BEGIN"
+  for l in sortedStmts do
+    IO.println l
+  IO.println "STMT-END"
+  IO.println s!"STMT-COUNT|{sortedStmts.size}"
 
 end LTLAccAudit
diff --git a/verification/check.sh b/verification/check.sh
index 82bcd30..23d021f 100755
--- a/verification/check.sh
+++ b/verification/check.sh
@@ -6,7 +6,9 @@
 # both directions.
 #
 # Phases: 0 resource/integrity · 1 stub+axiom-smuggling audit ·
-#         2 compile manifest · 3 boundary-exact axiom audit
+#         2 compile manifest · 3 boundary-exact axiom audit ·
+#         3b environment-derived coverage · 3c doc-consistency ·
+#         3d statement + specification binding · 4 definition fidelity
 # ─────────────────────────────────────────────────────────────────────────────
 set -euo pipefail
 # Toolchain bootstrap is overridable for reviewers with their own install
@@ -239,7 +241,8 @@ for cert in "${!CONES[@]}"; do
       "$HERE/inventory-allowlist.txt" || {
     echo "  PINNED BUT NOT INVENTORIED: $cert (in CONES, not in allowlist)"; COVFAIL=1; }
 done
-rm -f "$INVLOG"
+# (INVLOG is NOT removed here: Phase 3d binds the statement block emitted by
+#  this same run. Removed at the end of 3d.)
 
 # every pinned cert must actually be queried by AxiomCheck (no pin-but-never-check)
 for cert in "${!CONES[@]}"; do
@@ -276,6 +279,69 @@ print(' '.join(f'{int(v.replace(chr(95),\"\")):,}' for v in vals))"); do
 done
 [ "$DOCFAIL" = 0 ] && echo "  docs agree with allowlist ($NALLOW), CONES ($NCONES), fidelity pins"
 [ "$DOCFAIL" = 0 ] || { echo "DOC-CONSISTENCY FAILED"; exit 1; }
+# -- Phase 3d: statement + specification binding (P1-a) ---------------------
+# WHAT PHASES 3/3b DO NOT ESTABLISH. Phase 3 pins each certificate's exact
+# axiom cone; Phase 3b pins the full environment surface, kind and cone, both
+# directions. Neither records what a declaration SAYS. A theorem gutted to a
+# tautology keeps its name, its kind and its cone. A `def` redefined to BE the
+# thing it was meant to specify keeps all three, and every certificate stated
+# against it silently becomes vacuous — with the allowlist unmoved.
+#
+# Proofs/Inventory.lean therefore also emits, for every inventoried constant,
+# its fully-elaborated TYPE, and for every definition its fully-elaborated
+# BODY. Proof terms are deliberately absent: by proof irrelevance a theorem's
+# content is its statement. This phase binds the SHA-256 of that block, and
+# the block itself is committed as AUDIT-MANIFEST.txt so a mismatch is DIFFED
+# rather than merely reported.
+#
+# To rotate deliberately: run check.sh, take the printed OBSERVED digest, and
+# update the constant below AND AUDIT-MANIFEST.txt in the same reviewable
+# commit. Visibility in review is the defence; no harness audits its author.
+EXPECTED_STMT_SHA256="e7d422f0be9a9e6f5465058292e30c711d52856428da2b01c470a57ec181540c"
+echo "=== Phase 3d: statement + specification binding ==="
+STMTFAIL=0
+STMT_BLOCK=$(awk '/^STMT-BEGIN/{f=1;next} /^STMT-END/{f=0} f' "$INVLOG")
+# FAIL CLOSED ON ABSENCE: no block and a matching block must not share a path.
+if [ -z "$STMT_BLOCK" ]; then
+  echo "  NO STATEMENT BLOCK emitted by Proofs/Inventory.lean (fail-closed)"; STMTFAIL=1
+else
+  # Output integrity, same discipline as the INV-COUNT trailer: a truncated or
+  # crashed run must not pass as a short-but-matching block.
+  N_STMT=$(printf '%s\n' "$STMT_BLOCK" | grep -c '^STMT|')
+  STMT_TRAILER=$(grep '^STMT-COUNT|' "$INVLOG" | tail -1 | cut -d'|' -f2)
+  if [ -z "$STMT_TRAILER" ] || [ "$STMT_TRAILER" != "$N_STMT" ]; then
+    echo "  STATEMENT BLOCK TRUNCATED: trailer=${STMT_TRAILER:-absent}, observed $N_STMT"; STMTFAIL=1
+  fi
+  # Every inventoried constant must carry a statement line. Inventory.lean
+  # asserts this internally too; asserting it here as well means a tampered
+  # Inventory.lean cannot simply drop its own check.
+  N_INV=$(grep -c '^INV|' "$INVLOG")
+  N_TYPES=$(printf '%s\n' "$STMT_BLOCK" | grep -c '|type=')
+  if [ "$N_TYPES" != "$N_INV" ]; then
+    echo "  STATEMENT COVERAGE GAP: $N_INV constants inventoried, $N_TYPES carry a statement"; STMTFAIL=1
+  fi
+  GOT_STMT_SHA=$(printf '%s\n' "$STMT_BLOCK" | sha256sum | cut -d' ' -f1)
+  if [ "$GOT_STMT_SHA" != "$EXPECTED_STMT_SHA256" ]; then
+    printf '%s\n' "$STMT_BLOCK" > "$HERE/.stmt-manifest.observed"
+    echo "  STATEMENT DIGEST MISMATCH."
+    echo "    expected: $EXPECTED_STMT_SHA256"
+    echo "    observed: $GOT_STMT_SHA"
+    echo "    A statement or a definition body changed. First differences:"
+    diff -u "$HERE/AUDIT-MANIFEST.txt" "$HERE/.stmt-manifest.observed" 2>/dev/null \
+      | head -30 | sed 's/^/      /' || echo "      (AUDIT-MANIFEST.txt absent — cannot diff)"
+    rm -f "$HERE/.stmt-manifest.observed"
+    STMTFAIL=1
+  elif ! printf '%s\n' "$STMT_BLOCK" | cmp -s - "$HERE/AUDIT-MANIFEST.txt"; then
+    # The digest's INPUT must be committed and current, or the diff above would
+    # compare against a stale reference and quietly mislead the next reader.
+    echo "  COMMITTED BLOCK STALE: AUDIT-MANIFEST.txt does not match the emitted block"
+    echo "  (the digest matched, so the committed copy needs refreshing)"; STMTFAIL=1
+  fi
+fi
+[ "$STMTFAIL" = 0 ] && echo "  statements bound: $N_STMT lines over $N_INV constants, sha256 = $GOT_STMT_SHA"
+[ "$STMTFAIL" = 0 ] || { echo "STATEMENT BINDING FAILED"; rm -f "$INVLOG"; exit 1; }
+rm -f "$INVLOG"
+
 # -- Phase 4: definition fidelity (Lean defs vs deployed pacta verifiers) --
 echo "=== Phase 4: definition fidelity ==="
 PACTA_SRC="${PACTA_SRC:-$HERE/../../proof-aware-crypto-tooling-agent/src}"
diff --git a/verification/fidelity/run_fidelity.py b/verification/fidelity/run_fidelity.py
index ab0177b..05a1f62 100644
--- a/verification/fidelity/run_fidelity.py
+++ b/verification/fidelity/run_fidelity.py
@@ -39,10 +39,23 @@ import lean_defs as L                       # noqa: E402
 
 NMAX = int(os.environ.get("FIDELITY_NMAX", "256"))
 # lied-size family pins (gap 14; valid for the default FIDELITY_LIED_NMAX=60):
-# 73,573 boundary cases, 3,867 expected one-sided divergences
-# (3,405 lied-old-size + 462 lied-new-size), smallest witness (n=3, m=2 claimed 1)
+# 73,573 boundary cases.
+#
+# The divergence count was 3,867 (3,405 lied-old-size + 462 lied-new-size,
+# smallest witness n=3, m=2 claimed 1) until pacta `ddbb5a4` (2026-07-23)
+# restored the RFC 9162 2.1.4.2 Step-7 terminal condition `sn == 0` to
+# verify_consistency. That one conjunct removes EVERY divergence in this
+# family, so the pin is now 0: the deployed verifier and the mechanized
+# ConsRec model agree on all 73,573 boundary cases.
+#
+# The pin was left at 3,867 when the fix landed, which made this assertion —
+# and therefore check.sh Phase 4 — fail from 2026-07-23 until it was noticed
+# on 2026-07-28. KNOWN-GAPS.md gap 14 had already recorded the closure; only
+# this constant was stale. Nothing about the paper, public log entry 13, or
+# the attested commit 172a1d0 changes: the historical divergence remains
+# truthfully recorded and reproducible at `vulnerable/sn0-consistency-fd2f6ba`.
 LIED_PIN_TOTAL = 73_573
-LIED_PIN_DIV = 3_867
+LIED_PIN_DIV = 0
 
 
 def _h(b):
diff --git a/verification/selftest_statements.sh b/verification/selftest_statements.sh
new file mode 100755
index 0000000..5239d9c
--- /dev/null
+++ b/verification/selftest_statements.sh
@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# ─────────────────────────────────────────────────────────────────────────────
+# selftest_statements.sh — adversarial self-test of check.sh Phase 3d.
+#
+# WHY A SECOND SELF-TEST. selftest_audit.sh attacks the coverage gate, which
+# pins every constant's NAME, KIND and AXIOM CONE, both directions. That gate
+# is strong and none of its nine attacks defeat it. It is also blind to what a
+# declaration SAYS, and this script demonstrates that with a real, compiling
+# edit rather than an argument:
+#
+#   `LTLAcc.pinAccept` is a specification definition. Wrapping one branch of
+#   its body in `id (…)` is definitionally equal, so every downstream proof
+#   still compiles; the name, the kind, the type and the axiom cone are all
+#   unchanged. The inventory gate reports 222 constants, environment ==
+#   allowlist, GREEN. Only the statement digest sees it.
+#
+#   That edit is deliberately harmless. The point is that the ONLY thing
+#   standing between it and a genuinely vacuous redefinition is the digest.
+#
+# Cases:
+#   0  positive control: pristine tree passes Phase 3d
+#   1  defeq body edit: old gate PASSES (asserted), Phase 3d FAILS (asserted)
+#   2  committed AUDIT-MANIFEST.txt hand-edited      → COMMITTED BLOCK STALE
+#   3  statement block truncated                     → BLOCK TRUNCATED
+#   4  a constant inventoried but carrying no statement → COVERAGE GAP
+#
+# Phase 3d is lifted out of check.sh at run time, so the tested logic IS the
+# shipping logic. Run AFTER a green check.sh. All Lean work via lean-guard.
+# ─────────────────────────────────────────────────────────────────────────────
+set -uo pipefail
+AENEAS_ENV="${AENEAS_ENV:-$HOME/aeneas-toolchain/env.sh}"
+[ -f "$AENEAS_ENV" ] || { echo "FATAL: Aeneas environment not found: $AENEAS_ENV"; exit 1; }
+source "$AENEAS_ENV"
+SRC="$(cd "$(dirname "$0")" && pwd)"
+AENEAS_LEAN="$AENEAS_HOME/backends/lean"
+CORES="${LEAN_MAX_CORES:-0-3}"
+FAILURES=0
+
+WORK=$(mktemp -d /tmp/acc-stmt-selftest-XXXX)
+trap 'rm -rf "$WORK"' EXIT
+echo "=== statement-binding self-test (scratch: $WORK) ==="
+cp -a "$SRC" "$WORK/verification"
+T="$WORK/verification"
+cp "$T/Proofs/PinStore.lean" "$T/PinStore.pristine"
+cp "$T/AUDIT-MANIFEST.txt"   "$T/MANIFEST.pristine"
+
+# Phase 3d, lifted verbatim from the shipping button. HERE and INVLOG are the
+# two variables it reads from its surroundings.
+DRIVER="$T/phase3d.sh"
+{
+  echo 'set -uo pipefail'
+  echo "HERE=\"$T\""
+  echo 'INVLOG="$1"'
+  sed -n '/^# -- Phase 3d/,/^# -- Phase 4/p' "$SRC/check.sh" | sed '$d'
+} > "$DRIVER"
+if [ "$(wc -l < "$DRIVER")" -lt 40 ]; then
+  echo "FATAL: could not lift Phase 3d out of check.sh — the phase markers moved."
+  echo "This self-test must attack the shipping gate; refusing to run against nothing."
+  exit 1
+fi
+
+# Recompile the edited leaf module + the inventory into $T/inv.out.
+build_inventory() {
+  cd "$AENEAS_LEAN"
+  lake env bash -c "
+    set -euo pipefail
+    cd '$T' && export LEAN_PATH=\"\$LEAN_PATH:$T/gen:$T\"
+    LEAN_TIMEOUT=600 LEAN_MAX_CORES=$CORES '$T/lean-guard' Proofs/PinStore.lean >/dev/null 2>&1
+    LEAN_TIMEOUT=600 LEAN_MAX_CORES=$CORES '$T/lean-guard' Proofs/Inventory.lean
+  " > "$T/inv.out" 2>&1
+  local rc=$?
+  cd "$T"
+  return $rc
+}
+
+expect() {  # expect <label> <invlog> <want-rc> <want-substring>
+  local label="$1" invlog="$2" want_rc="$3" want_txt="$4" out rc
+  # Phase 3d removes its INVLOG on the way out — that is correct behaviour for
+  # the button and fatal for a fixture, so it always gets a disposable copy.
+  cp "$invlog" "$T/inv.feed"
+  out=$(bash "$DRIVER" "$T/inv.feed" 2>&1); rc=$?
+  if [ "$rc" -ne "$want_rc" ]; then
+    echo "  ✗ $label: exit $rc, expected $want_rc"; echo "$out" | sed 's/^/      /'
+    FAILURES=$((FAILURES+1)); return
+  fi
+  if ! grep -qF "$want_txt" <<<"$out"; then
+    echo "  ✗ $label: exit code right, diagnostic wrong (rejected for the wrong reason)"
+    echo "      wanted: $want_txt"; echo "$out" | sed 's/^/      /'
+    FAILURES=$((FAILURES+1)); return
+  fi
+  echo "  ✓ $label"
+}
+
+# ── 0. positive control ────────────────────────────────────────────────────
+build_inventory || { echo "  ✗ case 0: pristine tree did not compile"; exit 1; }
+cp "$T/inv.out" "$T/inv.pristine"
+expect "case 0 control: pristine tree passes Phase 3d" "$T/inv.pristine" 0 "statements bound"
+
+# ── 1. THE ONE THAT MATTERS: a compiling, definitionally-equal body edit ───
+python3 - "$T/Proofs/PinStore.lean" <<'PY'
+import sys
+f = sys.argv[1]; s = open(f).read()
+old = "  else ConsRec n n' C true r = some (r, r')"
+assert s.count(old) == 1, "pinAccept body not found — this case is vacuous"
+open(f, "w").write(s.replace(old, "  else id (ConsRec n n' C true r = some (r, r'))", 1))
+PY
+if build_inventory; then
+  # The premise: the coverage gate must NOT see this. If it ever does, this
+  # case stops testing what it claims and must be re-examined, not re-labelled.
+  if "$T/inventory_gate.sh" "$T/inv.out" "$T/inventory-allowlist.txt" >/dev/null 2>&1; then
+    echo "  ✓ case 1 premise: the coverage gate passes the edit (kind and cone unmoved)"
+  else
+    echo "  ✗ case 1 premise: the coverage gate caught it — this case no longer isolates Phase 3d"
+    FAILURES=$((FAILURES+1))
+  fi
+  expect "case 1: defeq body edit caught by the statement digest" "$T/inv.out" 1 "STATEMENT DIGEST MISMATCH"
+else
+  echo "  ✗ case 1: the edited corpus did not compile (case is vacuous)"
+  FAILURES=$((FAILURES+1))
+fi
+cp "$T/PinStore.pristine" "$T/Proofs/PinStore.lean"
+
+# ── 2. committed block hand-edited ─────────────────────────────────────────
+sed -i '1s/$/ TAMPERED/' "$T/AUDIT-MANIFEST.txt"
+expect "case 2: hand-edited committed block" "$T/inv.pristine" 1 "COMMITTED BLOCK STALE"
+cp "$T/MANIFEST.pristine" "$T/AUDIT-MANIFEST.txt"
+
+# ── 3. truncated block: "nothing found" must not pass for "nothing wrong" ──
+grep -v '^STMT|LTLAcc.pinAccept|def|value=' "$T/inv.pristine" > "$T/inv.truncated"
+expect "case 3: truncated statement block" "$T/inv.truncated" 1 "BLOCK TRUNCATED"
+
+# ── 4. a constant inventoried but carrying no statement ────────────────────
+#     Drop one type line AND fix the trailer, so only the coverage comparison
+#     against the INV count can still object.
+grep -v '^STMT|LTLAcc.pinAccept|def|type=' "$T/inv.pristine" > "$T/inv.gap"
+NEW_N=$(awk '/^STMT-BEGIN/{f=1;next}/^STMT-END/{f=0}f' "$T/inv.gap" | grep -c '^STMT|')
+sed -i "s/^STMT-COUNT|.*/STMT-COUNT|$NEW_N/" "$T/inv.gap"
+expect "case 4: inventoried constant with no statement" "$T/inv.gap" 1 "STATEMENT COVERAGE GAP"
+
+echo ""
+if [ "$FAILURES" -eq 0 ]; then
+  echo "=== SELF-TEST GREEN: 4 attack cases defeated + positive control ==="
+  echo "    Phase 3d catches what the coverage gate provably cannot see."
+  exit 0
+fi
+echo "=== SELF-TEST FAILED: $FAILURES case(s) did not behave as claimed ==="
+exit 1