saymrwulf/ltl-accumulator-verified
1
0
Fork 0
mirror of https://github.com/saymrwulf/ltl-accumulator-verified.git synced 2026-09-03 19:53:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
ltl-accumulator-verified/verification/AUDIT-MANIFEST.txt
mrwulf b575e857e3 verification: bind statements and specification bodies (P1-a); un-stale the fidelity pin 
STATEMENT BINDING (Phase 3d). The coverage gate pins every constant's name,
kind and axiom cone, both directions, and none of selftest_audit.sh's nine
attacks defeat it. It is nevertheless blind to what a declaration SAYS — and
that is demonstrated here rather than argued:

  Wrapping one branch of `LTLAcc.pinAccept`'s body in `id (…)` is
  definitionally equal. Every downstream proof still compiles. The name, the
  kind, the type and the axiom cone are unchanged. The inventory gate reports
  "222 constants, environment == allowlist" — GREEN.

That edit is harmless by construction; the point is that nothing stood between
it and a genuinely vacuous redefinition of a specification. Proofs/Inventory.lean
now also emits, for every inventoried constant, its fully-elaborated TYPE, and
for every definition its fully-elaborated BODY — 266 lines over 222 constants.
Proof terms are deliberately absent: by proof irrelevance a theorem's content
is its statement. check.sh Phase 3d binds the SHA-256 and the block is
committed as AUDIT-MANIFEST.txt so a mismatch is DIFFED, not merely reported.

The existing gate is untouched, per the standing rule that the port flows FROM
this repo, not to it: INV lines are byte-identical, inventory_gate.sh is
unchanged, and all nine of its attacks still fail as before.

selftest_statements.sh replays the defeq edit as case 1, asserting BOTH that
the coverage gate passes it and that Phase 3d catches it — so if the coverage
gate ever grows to see this, the test says so instead of quietly re-labelling.
Cases 2-4 cover a hand-edited committed block, a truncated block, and a
constant inventoried without a statement.

FIDELITY PIN (unrelated, found while running the button). Phase 4 had been
failing since 2026-07-23: LIED_PIN_DIV expected 3,867 divergences between the
Lean model and the deployed consistency verifier, and observed 0. Cause is
pacta ddbb5a4, which restored the RFC 9162 2.1.4.2 Step-7 terminal `sn == 0`
condition; that one conjunct removes every divergence in the pinned
73,573-case family. KNOWN-GAPS gap 14 already recorded the closure on the day
it landed — only this constant was stale, so the button had been red for five
days with nobody running it. The pin now reads 0 with the history in a comment.
Nothing about the paper, public log entry 13, or the attested commit 172a1d0
changes; the historical divergence stays reproducible at the tagged pre-fix
commit.

KNOWN-GAPS gap 16 records what the binding does not buy: identity, not
meaning; an author who edits and re-pins in one commit is caught by review and
not by the script; and proof terms are unbound by design.

Button green end to end: ATTESTATION GREEN (Lean + fidelity).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-29 09:07:13 +02:00

266 lines
322 KiB
Text
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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)
Reference in a new issue View git blame Copy permalink