[Imprint][Data Privacy Statement][E-Mail]



View long theorem info. View the proof. Back to main index. View the specification. View theorem base summary, View theorem base listing, the used properties by spec, the dependency list, the symbol table,

Proof step 1 from proof lemma_2-5-2 (conclusion) (back to tree)

⊦ fin(IOAut(startf, stepf)) → limit-closed(beh(IOAut(startf, stepf)))

System applied rule normalize

And obtained the following new goals

Rule argument

Additional information

Proof step 2 from proof lemma_2-5-2 (previous step) (back to tree)

fin(IOAut(startf, stepf)), ¬ limit-closed(beh(IOAut(startf, stepf))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 3 from proof lemma_2-5-2 (previous step) (back to tree)

fin(IOAut(startf, stepf)), ¬ limit-closed(beh(IOAut(startf, stepf))) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: traceprop, name:limitclosed-def, seq:⊦ limit-closed(tP) ↔ (∀ α1. ¬ finp(α1) ∧ ext(α1) ∧ (∀ α2. finp(α2) ∧ α2 ≤ α1 → tP(α2)) → tP(α1)), subst:[tP] → [beh(IOAut(startf, stepf))], <all paths>

Additional information

Used terms: beh(IOAut(startf, stepf))

Proof step 4 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ limit-closed(tP) ↔ (∀ α1. ¬ finp(α1) ∧ ext(α1) ∧ (∀ α2. finp(α2) ∧ α2 ≤ α1 → tP(α2)) → tP(α1))

A spec-lemma

Proof step 5 from proof lemma_2-5-2 (previous step) (back to tree)

fin(IOAut(startf, stepf)), ∃ α1. ¬(¬ finp(α1) ∧ ext(α1) ∧ (∀ α2. finp(α2) ∧ α2 ≤ α1 → beh(IOAut(startf, stepf))(α2)) → beh(IOAut(startf, stepf))(α1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: beh-def: ⊦ beh(IOAut(startf, stepf))(α) ↔ trace(IOAut(startf, stepf))(α); ⊦ ¬ finp(⌜nf⌝ ); (s) stream-inf-forward: ⊦ ¬ finp(σ) → (∃ nf. ⌜nf⌝ = σ); (forward) from specification stream-basic[actionstream]

Proof step 6 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: Koenigs-Lemma-gen[Koenigs-Lemma-gen-behact], name:KoenigsLemma, seq:infgraph(g), finroot(g), finout(g), allreachable(g) ⊦ ∃ nf. isroot(g)(nf(0)) ∧ pathp(g)(⌜nf⌝ ), subst:[g] → [ (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))]

Additional information

Used terms: (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 7 from proof lemma_2-5-2 (previous step) (back to tree)

infgraph(g), finroot(g), finout(g), allreachable(g) ⊦ ∃ nf. isroot(g)(nf(0)) ∧ pathp(g)(⌜nf⌝ )

A spec-lemma

Proof step 8 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ infgraph ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ∧ finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ∧ finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ∧ allreachable ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 1

Additional information

Proof step 9 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ infgraph ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: Koenigs-Lemma-gen[Koenigs-Lemma-gen-behact], name:infgraph-def, seq: ⊦ infgraph(g) ↔ (∀ s. ∃ a. dom(g)(a) ∧ ¬ a ∈ s), subst:[g] → [ (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 10 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ infgraph(g) ↔ (∀ s. ∃ a. dom(g)(a) ∧ ¬ a ∈ s)

A spec-lemma

Proof step 11 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ _s. ∃ _a. dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ dom(vs × es) = vs; (s)

Proof step 12 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∃ n. ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝

Additional information

Used formulas: ∃ n. ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝

Proof step 13 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ n. ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 14 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 5 terms: ⌜af to n⌝ abort: F discard: F computed: F

Additional information

Used terms: ⌜af to n⌝

Proof step 15 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), finp(⌜af to n⌝ ) ∧ ⌜af to n⌝ ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(⌜af to n⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜nf to n⌝ ); (s)

Proof step 16 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ⌜af to n⌝ ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(⌜af to n⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜af to n⌝ ≤ ⌜af⌝

Additional information

Used formulas: ⌜af to n⌝ ≤ ⌜af⌝

Proof step 17 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ⌜af to n⌝ ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(⌜af to n⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 18 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), trace(IOAut(startf, stepf))(⌜af to n⌝ ), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:trace, seq:⊦ trace(IOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ exec(IOAut(startf, stepf))(σ, β)), subst:[α, stepf, startf] → [⌜af to n⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜af to n⌝ , stepf, startf

Proof step 19 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ trace(IOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ exec(IOAut(startf, stepf))(σ, β))

A spec-lemma

Proof step 20 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∃ σ, β. ⌜af to n⌝ = β ^ ∧ exec(IOAut(startf, stepf))(σ, β) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)

Proof step 21 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = α ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, α), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;;

Proof step 22 from proof lemma_2-5-2 (previous step) (back to tree)

α = ⌜al0⌝ , ⌜af to n⌝ = α ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, α), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 23 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)

Proof step 24 from proof lemma_2-5-2 (previous step) (back to tree)

σ = ⌜sl0⌝ , ⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 25 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: ⌜af to n⌝ × sl0.last abort: F discard: T computed: F

Additional information

Used terms: ⌜af to n⌝ × sl0.last

Proof step 26 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ after(IOAut(startf, stepf))(actstream(⌜af to n⌝ × sl0.last), endstate(⌜af to n⌝ × sl0.last)) ∧ actstream(⌜af to n⌝ × sl0.last) ≤ ⌜af⌝ ∧ finp(actstream(⌜af to n⌝ × sl0.last)) ∧ ¬ ⌜af to n⌝ × sl0.last ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜nf to n⌝ ); (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s)

Proof step 27 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last) ∧ ¬ ⌜af to n⌝ × sl0.last ∈ _s

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 8 terms: ⌜af to n⌝ × sl0.last abort: F discard: T computed: T

Additional information

Used terms: ⌜af to n⌝ × sl0.last

Proof step 28 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ⌜af to n⌝ × sl0.last ∈ _s ∧ after(IOAut(startf, stepf))(actstream(⌜af to n⌝ × sl0.last), endstate(⌜af to n⌝ × sl0.last)) → # actstream(⌜af to n⌝ × sl0.last) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last) ∧ ¬ ⌜af to n⌝ × sl0.last ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s)

Proof step 29 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last) ∧ ¬ ⌜af to n⌝ × sl0.last ∈ _s, ⌜af to n⌝ × sl0.last ∈ _s ∧ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last)

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last)

Additional information

Used formulas: after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last)

Proof step 30 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ⌜af to n⌝ × sl0.last ∈ _s ∧ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last), after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last) ∧ ¬ ⌜af to n⌝ × sl0.last ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 31 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜af to n⌝ , sl0.last), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [sl0.last, ⌜af to n⌝ , stepf, startf], <all paths>

Additional information

Used terms: sl0.last, ⌜af to n⌝ , stepf, startf

Proof step 32 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 33 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. ¬(α ^ = ⌜af to n⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ sl0.last = σ.l.last) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 34 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜al0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), startf(sl0[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. α ^ ≠ ⌜af to n⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ∨ ¬ finp(α) ∨ sl0.last ≠ σ.l.last ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 9 terms: ⌜al0⌝ , ⌜sl0⌝

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ .l = x; (s) Used terms: ⌜al0⌝ , ⌜sl0⌝

Proof step 35 from proof lemma_2-5-2 (previous step) (back to tree)

α = ⌜af0⌝ , ⌜af to n⌝ = α ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, α), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 36 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-to-strong, seq: ⊦ ¬ # α ^ < ⌜n⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to n = (α to m)^), subst:[α, n] → [⌜af0⌝ , n]

Additional information

Used terms: ⌜af0⌝ , n

Proof step 37 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ¬ # α ^ < ⌜n⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to n = (α to m)^)

A spec-lemma

Proof step 38 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # ⌜af0⌝ ^ < ⌜n⌝ → (∃ m. ¬ # ⌜af0⌝ < ⌜m⌝ ∧ ⌜af0⌝ ^ to n = (⌜af0⌝ to m)^), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ (nf to n) to n = nf to n; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ¬ n < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 39 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜af⌝ ); (s)

Proof step 40 from proof lemma_2-5-2 (previous step) (back to tree)

σ = ⌜sf0⌝ , ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ), startf(σ[0]), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ [n] = nf(n); (s)

Proof step 41 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: ⌜af to n⌝ × sf0(n0) abort: F discard: T computed: F

Additional information

Used terms: ⌜af to n⌝ × sf0(n0)

Proof step 42 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(actstream(⌜af to n⌝ × sf0(n0)), endstate(⌜af to n⌝ × sf0(n0))) ∧ actstream(⌜af to n⌝ × sf0(n0)) ≤ ⌜af⌝ ∧ finp(actstream(⌜af to n⌝ × sf0(n0))) ∧ ¬ ⌜af to n⌝ × sf0(n0) ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜nf to n⌝ ); (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s)

Proof step 43 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)) ∧ ¬ ⌜af to n⌝ × sf0(n0) ∈ _s

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 10 terms: ⌜af to n⌝ × sf0(n0) abort: F discard: T computed: T

Additional information

Used terms: ⌜af to n⌝ × sf0(n0)

Proof step 44 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ⌜af to n⌝ × sf0(n0) ∈ _s ∧ after(IOAut(startf, stepf))(actstream(⌜af to n⌝ × sf0(n0)), endstate(⌜af to n⌝ × sf0(n0))) → # actstream(⌜af to n⌝ × sf0(n0)) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)) ∧ ¬ ⌜af to n⌝ × sf0(n0) ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s)

Proof step 45 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)) ∧ ¬ ⌜af to n⌝ × sf0(n0) ∈ _s, ⌜af to n⌝ × sf0(n0) ∈ _s ∧ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0))

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0))

Additional information

Used formulas: after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0))

Proof step 46 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ⌜af to n⌝ × sf0(n0) ∈ _s ∧ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)), after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)) ∧ ¬ ⌜af to n⌝ × sf0(n0) ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 47 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜af to n⌝ , sf0(n0)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [sf0(n0), ⌜af to n⌝ , stepf, startf], <all paths>

Additional information

Used terms: sf0(n0), ⌜af to n⌝ , stepf, startf

Proof step 48 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 49 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. ¬(α ^ = ⌜af to n⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ sf0(n0) = σ.l.last) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 50 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. α ^ ≠ ⌜af to n⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ∨ ¬ finp(α) ∨ sf0(n0) ≠ σ.l.last ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 10 terms: ⌜af0 to n0⌝ , ⌜sf0 to n0 + 1⌝ abort: F discard: T computed: F

Additional information

Used terms: ⌜af0 to n0⌝ , ⌜sf0 to n0 + 1⌝

Proof step 51 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ⌜af0 to n0⌝ ^ ≠ ⌜af to n⌝ ∨ ¬ frag(IOAut(startf, stepf))(⌜sf0 to n0 + 1⌝ , ⌜af0 to n0⌝ ) ∨ ¬ startf(⌜sf0 to n0 + 1⌝ [0]) ∨ ¬ finp(⌜af0 to n0⌝ ) ∨ sf0(n0) ≠ ⌜sf0 to n0 + 1⌝ .l.last ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ finp(⌜nf to n⌝ ); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 52 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sf0 to n0 + 1⌝ , ⌜af0 to n0⌝ ) ∨ sf0(n0) ≠ (sf0 to n0 + 1).last ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:to-unwind-end-inf, seq: ⊦ nf to m + 1 = (nf to m) + nf(m) ', subst:[m, nf] → [n0, sf0], <all paths>

Additional information

Used terms: n0, sf0

Proof step 53 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ nf to m + 1 = (nf to m) + nf(m) '

A spec-lemma

Proof step 54 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜(sf0 to n0) + sf0(n0) '⌝ , ⌜af0 to n0⌝ ) ∨ sf0(n0) ≠ ((sf0 to n0) + sf0(n0) ').last ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 55 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ frag(IOAut(startf, stepf))(⌜sf0 to n0⌝ + ⌜sf0(n0) '⌝ , ⌜af0 to n0⌝ ), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag-to, seq:⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n), subst:[stepf, n, α, σ, startf] → [stepf, n0, ⌜af0⌝ , ⌜sf0⌝ , startf]

Additional information

Used terms: startf, stepf, ⌜sf0⌝ , ⌜af0⌝ , n0

Proof step 56 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n)

A spec-lemma

Proof step 57 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0 to n0⌝ ^, ⌜af to n⌝ = ⌜af0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ frag(IOAut(startf, stepf))(⌜sf0 to n0⌝ + ⌜sf0(n0) '⌝ , ⌜af0 to n0⌝ ), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ) ∧ ¬ # ⌜af0⌝ < ⌜n0⌝ → frag*(IOAut(startf, stepf))(⌜sf0⌝ to n0 + 1, ⌜af0⌝ to n0), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜nf to n⌝ ); (s) ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 58 from proof lemma_2-5-2 (previous step) (back to tree)

⌜af to n⌝ = ⌜af0⌝ ^, ⌜af to n⌝ = ⌜af0 to n0⌝ ^, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), frag(IOAut(startf, stepf))(⌜sf0 to n0 + 1⌝ , ⌜af0 to n0⌝ ), startf(sf0(0)), ⌜af to n⌝ ≤ ⌜af⌝ , ¬ frag(IOAut(startf, stepf))(⌜sf0 to n0⌝ + ⌜sf0(n0) '⌝ , ⌜af0 to n0⌝ ), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:to-unwind-end-inf, seq: ⊦ nf to m + 1 = (nf to m) + nf(m) ', subst:[m, nf] → [n0, sf0], <all paths>

Additional information

Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] Used terms: n0, sf0

Proof step 59 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ nf to m + 1 = (nf to m) + nf(m) '

A spec-lemma

Proof step 60 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ ⌜af to n⌝ ≤ ⌜af⌝ , ⌜af to n⌝ ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(⌜af to n⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 61 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ ⌜af to n⌝ ≤ ⌜af⌝ , ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:prefix-def, seq: ⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2), subst:[σ2, σ1] → [⌜af⌝ , ⌜af to n⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝ , ⌜af to n⌝

Proof step 62 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2)

A spec-lemma

Proof step 63 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α. ⌜af to n⌝ + α ≠ ⌜af⌝ ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s

User applied rule all left

And closed the goal!

Rule argument

pos: left 6 terms: ⌜af from n⌝ abort: F discard: T computed: F

Additional information

Used simplifier rules: ⊦ ⌜nf to n⌝ + ⌜nf from n⌝ = ⌜nf⌝ ↔ true; (ss) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used terms: ⌜af from n⌝

Proof step 64 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. after(IOAut(startf, stepf))(actstream(_a), endstate(_a)) ∧ actstream(_a) ≤ ⌜af⌝ ∧ finp(actstream(_a)) ∧ ¬ _a ∈ _s, ∃ n. ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: right 1

Additional information

Proof step 65 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ αs. αs ∈ _s ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝

User applied rule structural induction

And obtained the following new goals

Rule argument

indvar: _s

Additional information

Used simplifier rules: afterpairset generated by ∅, ++;; ⊦ ¬ a ∈ ∅; (s)

Proof step 66 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ af, startf, stepf. ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ n. ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ) ⊦ ∃ n. ∀ αs. αs ∈ _s0 ++ afterpair ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ a ∈ s ++ b ↔ a = b ∨ a ∈ s; (s)

Proof step 67 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ af, startf, stepf. ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ n. ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 4 terms: af, startf, stepf abort: F discard: T computed: T

Additional information

Used terms: af, startf, stepf

Proof step 68 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ n. ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 69 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: n abort: F discard: F computed: T

Additional information

Used terms: n

Proof step 70 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝ , ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 71 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # actstream(afterpair0) < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , afterpair0 = afterpair ∨ afterpair0 ∈ _s0 ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [afterpair0, α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: afterpair0, ασ, st

Proof step 72 from proof lemma_2-5-2 (previous step) (back to tree)

afterpair0 = α × s, after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), afterpair0 = afterpair ∨ afterpair0 ∈ _s0 ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 73 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , α × s = afterpair ∨ α × s ∈ _s0 ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 8

Additional information

Proof step 74 from proof lemma_2-5-2 (previous step) (back to tree)

α × s = afterpair, after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 75 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ n. ∀ afterpair0. (afterpair0 = α × s ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [s, α, stepf, startf], <all paths>

Additional information

Used terms: s, α, stepf, startf

Proof step 76 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 77 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ α0, σ. α0 ^ = α ∧ exec*(IOAut(startf, stepf))(σ, α0) ∧ s = σ.l.last ⊦ ∃ n. ∀ afterpair0. (afterpair0 = α × s ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 78 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ¬ # ⌜al⌝ ^ < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦ ∃ n. ∀ afterpair0. (afterpair0 = ⌜al⌝ ^ × σ.l.last ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: # al + 1 abort: F discard: T computed: F

Additional information

Used terms: # al + 1

Proof step 79 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ¬ # ⌜al⌝ ^ < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ afterpair0. (afterpair0 = ⌜al⌝ ^ × σ.l.last ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜# al + 1⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic[Koenigs-Lemma-gen-behact] ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic[Koenigs-Lemma-gen-behact] ⊦ ¬ ⌜# al⌝ < # ⌜al⌝ ^; (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)

Proof step 80 from proof lemma_2-5-2 (previous step) (back to tree)

# _s0 ≠ 0, _s0 ≠ ∅, afterpair0 ≠ ⌜al⌝ ^ × σ.l.last, ⌜# al⌝ < # actstream(afterpair0), after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), afterpair0 ∈ _s0, ¬ # ⌜al⌝ ^ < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [afterpair0, α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: afterpair0, ασ, st

Proof step 81 from proof lemma_2-5-2 (previous step) (back to tree)

afterpair0 = α × s, # _s0 ≠ 0, _s0 ≠ ∅, afterpair0 ≠ ⌜al⌝ ^ × σ.l.last, ⌜# al⌝ < # α, after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), afterpair0 ∈ _s0, ¬ # ⌜al⌝ ^ < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 82 from proof lemma_2-5-2 (previous step) (back to tree)

# _s0 ≠ 0, _s0 ≠ ∅, α × s ≠ ⌜al⌝ ^ × σ.l.last, ⌜# al⌝ < # α, after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), α × s ∈ _s0, ¬ # ⌜al⌝ ^ < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 14 terms: α × s abort: F discard: T computed: F

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) ⊦ actstream(ασ × st) = ασ; (s) lsle-trans: ⊦ n∞ < n∞1 ∧ ¬ n∞2 < n∞1 → n∞ < n∞2; (forward) from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ls-trans: ⊦ n∞ < n∞1 ∧ n∞1 < n∞2 → n∞ < n∞2; (forward) from specification nat-inf ⊦ m < n → n ≠ 0; (s) ⊦ ¬ ⌜# al⌝ < # ⌜al⌝ ^; (s) Used terms: α × s

Proof step 83 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), α × s ∈ _s0, ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic[Koenigs-Lemma-gen-behact] ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic[Koenigs-Lemma-gen-behact]

Proof step 84 from proof lemma_2-5-2 (previous step) (back to tree)

# _s0 ≠ 0, _s0 ≠ ∅, after(IOAut(startf, stepf))(α, s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), α × s ∈ _s0, ¬ # α < ⌜n⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ αs. αs ∈ _s0 ∧ after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) → # actstream(αs) < ⌜n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ n. ∀ afterpair0. (afterpair0 = afterpair ∨ afterpair0 ∈ _s0) ∧ after(IOAut(startf, stepf))(actstream(afterpair0), endstate(afterpair0)) → # actstream(afterpair0) < ⌜n⌝

User applied rule all left

And closed the goal!

Rule argument

pos: left 9 terms: α × s abort: F discard: T computed: F

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) ⊦ actstream(ασ × st) = ασ; (s) Used terms: α × s

Proof step 85 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: <toplevel>, name:finroot, seq:fin(IOAut(startf, stepf)), ∀ α0. finp(α0) ∧ α0 ≤ α → trace(IOAut(startf, stepf))(α0) ⊦ finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ α ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))), subst:[α, stepf, startf] → [⌜af⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜af⌝ , stepf, startf

Proof step 86 from proof lemma_2-5-2 (previous step) (back to tree)

fin(IOAut(startf, stepf)), ∀ α0. finp(α0) ∧ α0 ≤ α → trace(IOAut(startf, stepf))(α0) ⊦ finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ α ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Lemma finroot

Proof step 87 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ fin(IOAut(startf, stepf)) ∧ (∀ α0. finp(α0) ∧ α0 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α0)), finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]

Proof step 88 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ trace(IOAut(startf, stepf))(⌜al⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ finroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 6 terms: ⌜al⌝

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) Used terms: ⌜al⌝

Proof step 89 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: <toplevel>, name:finout, seq:fin(IOAut(startf, stepf)), ∀ α0. finp(α0) ∧ α0 ≤ α → trace(IOAut(startf, stepf))(α0) ⊦ finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ α ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))), subst:[α, stepf, startf] → [⌜af⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜af⌝ , stepf, startf

Proof step 90 from proof lemma_2-5-2 (previous step) (back to tree)

fin(IOAut(startf, stepf)), ∀ α0. finp(α0) ∧ α0 ≤ α → trace(IOAut(startf, stepf))(α0) ⊦ finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ α ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Lemma finout

Proof step 91 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ fin(IOAut(startf, stepf)) ∧ (∀ α0. finp(α0) ∧ α0 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α0)), finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]

Proof step 92 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ trace(IOAut(startf, stepf))(⌜al⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ finout ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 6 terms: ⌜al⌝

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) Used terms: ⌜al⌝

Proof step 93 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ allreachable ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2))))

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: Koenigs-Lemma-gen[Koenigs-Lemma-gen-behact], name:allreachable-def, seq: ⊦ allreachable(g) ↔ (∀ b. dom(g)(b) → (∃ a. isroot(g)(a) ∧ path(g)(a, b))), subst:[g] → [ (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 94 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ allreachable(g) ↔ (∀ b. dom(g)(b) → (∃ a. isroot(g)(a) ∧ path(g)(a, b)))

A spec-lemma

Proof step 95 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ b. dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (b) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, b))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ dom(vs × es) = vs; (s)

Proof step 96 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ = actstream(b), after(IOAut(startf, stepf))(⌜al⌝ , endstate(b)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, b)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [b, α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: b, ασ, st

Proof step 97 from proof lemma_2-5-2 (previous step) (back to tree)

b = α × s, ⌜al⌝ = α, after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, b)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 98 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

User applied rule induction

And obtained the following new goals

Rule argument

indvar: # al wfpred: <

Additional information

Used simplifier rules: <; (wellfounded) Used terms: # al

Proof step 99 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 100 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: al = []

Additional information

Used formulas: al = []

Proof step 101 from proof lemma_2-5-2 (previous step) (back to tree)

al = [], after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ [] ≤ σ; (s)

Proof step 102 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, [] × s)

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: [] × s abort: F discard: T computed: T

Additional information

Used terms: [] × s

Proof step 103 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ([] × s) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ([] × s, [] × s)

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 1

Additional information

Proof step 104 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ([] × s)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:isroot-def, seq: ⊦ isroot(g)(b) ↔ dom(g)(b) ∧ (∀ a. ¬ edge(g)(a, b)), subst:[b, g] → [[] × s, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: [] × s, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 105 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ isroot(g)(b) ↔ dom(g)(b) ∧ (∀ a. ¬ edge(g)(a, b))

A spec-lemma

Proof step 106 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ([] × s) ∧ (∀ _a. ¬ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, [] × s))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp([]); (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ [] ≤ σ; (s) ⊦ endstate(ασ × st) = st; (s) ⊦ dom(vs × es) = vs; (s)

Proof step 107 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, [] × s), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen-basic[Koenigs-Lemma-gen-behact], name:edge-def, seq: ⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b), subst:[b, a, es, vs] → [[] × s, _a, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))], <all paths>

Additional information

Used simplifier rules: ⊦ actstream(ασ × st) = ασ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a ' ≠ []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used terms: [] × s, _a, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))

Proof step 108 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b)

A spec-lemma

Proof step 109 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ([] × s, [] × s)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:path-def, seq: ⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last), subst:[b, a, g] → [[] × s, [] × s, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: [] × s, [] × s, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 110 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last)

A spec-lemma

Proof step 111 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ x. pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜x⌝ ) ∧ x ≠ [] ∧ [] × s = x.head ∧ [] × s = x.last

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: ([] × s)' abort: F discard: T computed: F

Additional information

Used terms: ([] × s)'

Proof step 112 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜([] × s)'⌝ ) ∧ ([] × s)' ≠ [] ∧ [] × s = ([] × s)'.head ∧ [] × s = ([] × s)'.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ a '.last = a; (s) ⊦ a '.head = a; (s) ⊦ a ' ≠ []; (s)

Proof step 113 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))([], s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # [] → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜([] × s)'⌝ )

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:pathp-def, seq:⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1])), subst:[σ, g] → [⌜([] × s)'⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used simplifier rules: ⊦ m < 1 ↔ m = 0; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ dom(vs × es) = vs; (s) ⊦ endstate(ασ × st) = st; (s) ⊦ [] ≤ σ; (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ finp([]); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ ↔ n∞2 < ⌜n - m⌝ ); (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ¬ n < 0; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: ⌜([] × s)'⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 114 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1]))

A spec-lemma

Proof step 115 from proof lemma_2-5-2 (previous step) (back to tree)

al ≠ [], after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∃ al0, a. al0 + a = al

Additional information

Used formulas: ∃ al0, a. al0 + a = al

Proof step 116 from proof lemma_2-5-2 (previous step) (back to tree)

al ≠ [], after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ al0, a. al0 + a = al, ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ x + a ' ≠ []; (s)

Proof step 117 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, (⌜al0⌝ + ⌜a '⌝ ) × s)

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: a = τ

Additional information

Used formulas: a = τ

Proof step 118 from proof lemma_2-5-2 (previous step) (back to tree)

a = τ, after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, (⌜al0⌝ + ⌜a '⌝ ) × s)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 119 from proof lemma_2-5-2 (previous step) (back to tree)

after(IOAut(startf, stepf))(⌜al0⌝ + ⌜τ '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al0⌝ + ⌜τ '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + τ) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, (⌜al0⌝ + ⌜τ '⌝ ) × s)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [s, ⌜al0⌝ + ⌜τ '⌝ , stepf, startf], <all paths>

Additional information

Used simplifier rules: ⊦ α0 ^ = α + ⌜τ '⌝ ↔ ¬ ¬(α0 ^ = α ∧ ¬ finp(α)); (s) ⊦ finp(⌜x⌝ ); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used terms: s, ⌜al0⌝ + ⌜τ '⌝ , stepf, startf

Proof step 120 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 121 from proof lemma_2-5-2 (previous step) (back to tree)

a ≠ τ, after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, (⌜al0⌝ + ⌜a '⌝ ) × s)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [s, ⌜al0⌝ + ⌜a '⌝ , stepf, startf], <all paths>

Additional information

Used terms: s, ⌜al0⌝ + ⌜a '⌝ , stepf, startf

Proof step 122 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 123 from proof lemma_2-5-2 (previous step) (back to tree)

a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ α, σ. α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, (⌜al0⌝ + ⌜a '⌝ ) × s)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 124 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-split, seq: ⊦ α ^ = ⌜al⌝ + β2 → (∃ α1, α2. α1 ^ = ⌜al⌝ ∧ α2 ^ = β2 ∧ α1 + α2 = α), subst:[α, al, β2] → [⌜al⌝ , al0, ⌜a '⌝ ]

Additional information

Used terms: ⌜al⌝ , al0, ⌜a '⌝

Proof step 125 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ α ^ = ⌜al⌝ + β2 → (∃ α1, α2. α1 ^ = ⌜al⌝ ∧ α2 ^ = β2 ∧ α1 + α2 = α)

A spec-lemma

Proof step 126 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ → (∃ α1, α2. α1 ^ = ⌜al0⌝ ∧ α2 ^ = ⌜a '⌝ ∧ α1 + α2 = ⌜al⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 127 from proof lemma_2-5-2 (previous step) (back to tree)

α1 + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , α1 ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α1

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ + σ = ⌜nf⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ ≠ ⌜nf⌝ ; (s)

Proof step 128 from proof lemma_2-5-2 (previous step) (back to tree)

α1 + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , α1 ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , α1 = ⌜al1⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 129 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule apply induction

And obtained the following new goals

Rule argument

subst: [al1, startf, stepf, s, af] → [al0, startf, stepf, σ[# al1], af]

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ n < n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: al0, startf, stepf, σ[# al1], af

Proof step 130 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last), after(IOAut(startf, stepf))(⌜al0⌝ , σ[# al1]) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 131 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last), after(IOAut(startf, stepf))(⌜al0⌝ , σ[# al1]) ∧ ⌜al0⌝ ≤ ⌜af⌝

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 2

Additional information

Proof step 132 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜al0⌝ , σ[# al1]), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: right 1

Additional information

Proof step 133 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜al0⌝ , σ[# al1]), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [σ[# al1], ⌜al0⌝ , stepf, startf], <all paths>

Additional information

Used terms: σ[# al1], ⌜al0⌝ , stepf, startf

Proof step 134 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 135 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ0. ¬(α ^ = ⌜al0⌝ ∧ exec*(IOAut(startf, stepf))(σ0, α) ∧ σ[# al1] = σ0.l.last), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 136 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ0. α ^ ≠ ⌜al0⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ0, α) ∨ ¬ startf(σ0[0]) ∨ ¬ finp(α) ∨ σ[# al1] ≠ σ0.l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 13 terms: ⌜al1⌝ , σ to # al1 + 1 abort: F discard: T computed: F

Additional information

Used terms: ⌜al1⌝ , σ to # al1 + 1

Proof step 137 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ⌜al1⌝ ^ ≠ ⌜al0⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ to # al1 + 1, ⌜al1⌝ ) ∨ ¬ startf((σ to # al1 + 1)[0]) ∨ ¬ finp(⌜al1⌝ ) ∨ σ[# al1] ≠ (σ to # al1 + 1).l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)

Proof step 138 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(σ to # al1 + 1, ⌜al1⌝ ) ∨ ¬ startf((σ to # al1 + 1)[0]) ∨ σ[# al1] ≠ (σ to # al1 + 1).l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)

Proof step 139 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , σ = ⌜sl0⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(σ to # al1 + 1, ⌜al1⌝ ) ∨ ¬ startf((σ to # al1 + 1)[0]) ∨ σ[# al1] ≠ (σ to # al1 + 1).l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 140 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α2

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜x⌝ ≠ σ + ⌜nf0⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]

Proof step 141 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , α2 = ⌜al2⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s)

Proof step 142 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag-to, seq:⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n), subst:[stepf, n, α, σ, startf] → [stepf, # al1, ⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , startf]

Additional information

Used terms: startf, stepf, ⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ , # al1

Proof step 143 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n)

A spec-lemma

Proof step 144 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ) ∧ ¬ #(⌜al1⌝ + ⌜al2⌝ ) < ⌜# al1⌝ → frag*(IOAut(startf, stepf))(⌜sl0⌝ to # al1 + 1, ⌜al1⌝ + ⌜al2⌝ to # al1), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + σ to # x = ⌜x⌝ ; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ m + n < m; (s) ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 145 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:get-finto, seq:¬ # x < n, m < n ⊦ (x to n)[m] = x[m], subst:[m, n, x] → [0, # al1 + 1, sl0], <all paths>

Additional information

Used terms: 0, # al1 + 1, sl0

Proof step 146 from proof lemma_2-5-2 (previous step) (back to tree)

¬ # x < n, m < n ⊦ (x to n)[m] = x[m]

A spec-lemma

Proof step 147 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ¬ # sl0 < # al1 + 1 ∧ 0 < # al1 + 1

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s)

Proof step 148 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf

Proof step 149 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 150 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜sl0⌝ = #(⌜al1⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), # sl0 ≤ # al1, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. ⌜n⌝ < #(⌜al1⌝ + ⌜al2⌝ ) → stepf(⌜sl0⌝ [n], (⌜al1⌝ + ⌜al2⌝ )[n], ⌜sl0⌝ [n +1]), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n1⌝ + ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n1 + n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 151 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 + 1 = # sl0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. n < # al1 + # al2 → stepf(sl0[n], (al1 + al2)[n], sl0[n + 1]), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 152 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # al1 + 1, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ # sl0 < # al1 + 1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf(sl0[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 153 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , sl0[# al1] ≠ (sl0 to # al1 + 1).last, a ≠ τ, sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(hd(sl0)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [sl0, s0, sl]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl0, s0, y

Proof step 154 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , sl0 = s0 + sl, sl0[# al1] ≠ (sl0 to # al1 + 1).last, a ≠ τ, sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(s0), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x to n + 1 = a + (x to n); (s) ⊦ a ' + x ≠ []; (s)

Proof step 155 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , (s0 ' + sl)[# al1] ≠ (s0 ' + (sl to # al1)).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s0), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜al1⌝ + ⌜al2⌝ , ⌜s0 '⌝ + ⌜sl⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜al1⌝ + ⌜al2⌝ , ⌜s0 '⌝ + ⌜sl⌝ , stepf, startf

Proof step 156 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 157 from proof lemma_2-5-2 (previous step) (back to tree)

#(⌜s0 '⌝ + ⌜sl⌝ ) = #(⌜al1⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , (s0 ' + sl)[# al1] ≠ (s0 ' + (sl to # al1)).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), startf(s0), # al1 ≤ # sl, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. ⌜n⌝ < #(⌜al1⌝ + ⌜al2⌝ ) → stepf((⌜s0 '⌝ + ⌜sl⌝ )[n], (⌜al1⌝ + ⌜al2⌝ )[n], (⌜s0 '⌝ + ⌜sl⌝ )[n +1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 158 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 = # sl, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , (s0 ' + sl)[# al1] ≠ (s0 ' + (sl to # al1)).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), startf(s0), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. n < # sl → stepf((s0 ' + sl)[n], (al1 + al2)[n], sl[n]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:at-last, seq: ⊦ x ≠ [] → x[# x - 1] = x.last, subst:[x] → [s0 ' + (sl to # al1)], <rotated> <all paths>

Additional information

Used simplifier rules: ⊦ x + y = [] ↔ x = [] ∧ y = []; (as) ⊦ a ' ≠ []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] Used terms: s0 ' + (sl to # al1)

Proof step 159 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x ≠ [] → x[# x - 1] = x.last

A spec-lemma

Proof step 160 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 = # sl, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , s0 ' + (sl to # al1) ≠ [], (s0 ' + sl)[# al1] ≠ (s0 ' + (sl to # al1))[#(s0 ' + (sl to # al1)) - 1], a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), startf(s0), # al1 ≤ # sl, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n. n < # sl → stepf((s0 ' + sl)[n], (al1 + al2)[n], sl[n]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s)

Proof step 161 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 = # sl, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , (s0 ' + sl)[# al1] ≠ (s0 ' + (sl to # al1))[# al1], a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s0 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), startf(s0), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. n < # sl → stepf((s0 ' + sl)[n], (al1 + al2)[n], sl[n]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:get-append-grt, seq: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x], subst:[n, y, x] → [# al1, sl, s0 '], <all paths>

Additional information

Used simplifier rules: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ n + 0 = n; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ 0 ≤ m; (s) ⊦ x to 0 = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ σ + [] = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ ⌜[]⌝ = []; (s) ⊦ frag(IOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ # [] = 0; (s) ⊦ # a ' = 0 +1; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ n < n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ n < # x → (x + y)[n] = x[n]; (s) Used terms: # al1, sl, s0 '

Proof step 162 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ¬ n < # x → (x + y)[n] = y[n - # x]

A spec-lemma

Proof step 163 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ ⌜al0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 4, flags: discard

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ0 + σ1 ≤ σ → (σ0 ≤ σ ↔ true); (ss)

Proof step 164 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × σ[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 165 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × σ[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)

Proof step 166 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , σ = ⌜sl0⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al⌝ ), startf(σ[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × σ[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × σ.l.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 167 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × sl0[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ _a0. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a0) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a0, ⌜al⌝ ^ × sl0.last)

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: _a abort: F discard: T computed: F

Additional information

Used terms: _a

Proof step 168 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × sl0[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × sl0.last)

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 1

Additional information

Proof step 169 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × sl0[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × sl0.last)

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 13

Additional information

Proof step 170 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × sl0[# al1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × sl0.last)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:path-def, seq: ⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last), subst:[b, a, g] → [⌜al0⌝ × sl0[# al1], _a, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: ⌜al0⌝ × sl0[# al1], _a, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 171 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last)

A spec-lemma

Proof step 172 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ x. pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜x⌝ ) ∧ x ≠ [] ∧ _a = x.head ∧ ⌜al0⌝ × sl0[# al1] = x.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ ^ × sl0.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 173 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x.last, a ≠ τ, x ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜x⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (x.head, ⌜al⌝ ^ × sl0.last)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[Koenigs-Lemma-gen-behact], name:elim-list-c, seq:x ≠ [] ⊦ a = x.head ∧ y = x.tail ↔ x = a + y, subst:[x, a, y] → [x, _a0, x0]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = x.head ∧ y = x.tail ↔ x = a + y; (elim) Used terms: x, _a0, y

Proof step 174 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , x = _a0 + x0, ⌜al0⌝ × sl0[# al1] = x.last, a ≠ τ, x ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜x⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a0, ⌜al⌝ ^ × sl0.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s) ⊦ a ' + x ≠ []; (s)

Proof step 175 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a0, ⌜al⌝ ^ × sl0.last)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:path-def, seq: ⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last), subst:[b, a, g] → [⌜al⌝ ^ × sl0.last, _a0, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: ⌜al⌝ ^ × sl0.last, _a0, (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 176 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ path(g)(a, b) ↔ (∃ x. pathp(g)(⌜x⌝ ) ∧ x ≠ [] ∧ a = x.head ∧ b = x.last)

A spec-lemma

Proof step 177 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ∃ x. pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜x⌝ ) ∧ x ≠ [] ∧ _a0 = x.head ∧ ⌜al⌝ ^ × sl0.last = x.last

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: _a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last)) abort: F discard: T computed: F

Additional information

Used terms: _a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last))

Proof step 178 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last))⌝ ) ∧ _a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last)) ≠ [] ∧ _a0 = (_a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last))).head ∧ ⌜al⌝ ^ × sl0.last = (_a0 ' + (x0 + (⌜al0 + a '⌝ × sl0.last))).last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ (a ' + x + b ').last = b; (s) ⊦ x + a = x + a '; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x).head = a; (s) ⊦ a ' + x ≠ []; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 179 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ )

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:pathp-def, seq:⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1])), subst:[σ, g] → [⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: ⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 180 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1]))

A spec-lemma

Proof step 181 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (∀ n. ⌜n⌝ < #(⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ ) → dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ )[n])) ∧ (∀ n. ⌜n + 1⌝ < #(⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ ) → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ )[n], (⌜_a0 '⌝ + ⌜x0⌝ + ⌜(⌜al⌝ ^ × sl0.last)'⌝ )[n + 1]))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[Koenigs-Lemma-gen-behact] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ + ⌜x1⌝ )[m] = (x + x0 + x1)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ dom(vs × es) = vs; (s) ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s)

Proof step 182 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ( n < 2 + # x0 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n]), endstate((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n])) ∧ actstream((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n]))) ∧ ( ¬ # x0 < n0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0]))

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [(_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n], α, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n], ασ, st

Proof step 183 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜_a0 '⌝ + ⌜x0⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (n < 2 + # x0 → after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)) ∧ ( ¬ # x0 < n0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0]))

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:pathp-def, seq:⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1])), subst:[σ, g] → [⌜_a0 '⌝ + ⌜x0⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: ⌜_a0 '⌝ + ⌜x0⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 184 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1]))

A spec-lemma

Proof step 185 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n. ⌜n⌝ < #(⌜_a0 '⌝ + ⌜x0⌝ ) → dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((⌜_a0 '⌝ + ⌜x0⌝ )[n]), ∀ n. ⌜n + 1⌝ < #(⌜_a0 '⌝ + ⌜x0⌝ ) → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((⌜_a0 '⌝ + ⌜x0⌝ )[n], (⌜_a0 '⌝ + ⌜x0⌝ )[n + 1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (n < 2 + # x0 → after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)) ∧ ( ¬ # x0 < n0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0]))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ dom(vs × es) = vs; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[Koenigs-Lemma-gen-behact] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)

Proof step 186 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (n < 2 + # x0 → after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)) ∧ ( ¬ # x0 < n0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0]))

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 1

Additional information

Proof step 187 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 188 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 15 terms: n abort: F discard: T computed: F

Additional information

Used terms: n

Proof step 189 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # x0 < n → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n]), endstate((_a0 ' + x0)[n])) ∧ actstream((_a0 ' + x0)[n]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [(_a0 ' + x0)[n], α0, s1]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: (_a0 ' + x0)[n], ασ, st

Proof step 190 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, (_a0 ' + x0)[n] = α0 × s1, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # x0 < n → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[Koenigs-Lemma-gen-behact], name:get-append-less, seq: ⊦ n < # x → (x + y)[n] = x[n], subst:[n, y, x] → [n, x0, _a0 '], <all paths>

Additional information

Used simplifier rules: ⊦ n < # x → (x + y)[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ a '[0] = a; (s) ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) ⊦ 0 < m ↔ m ≠ 0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ¬ n < 0; (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] Used terms: n, x0, _a0 '

Proof step 191 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + y)[n] = x[n]

A spec-lemma

Proof step 192 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0)[n] = α0 × s1, (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ n < # _a0 ', ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # x0 < n → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s)

Proof step 193 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (x0 + (⌜al⌝ ^ × sl0.last)')[n - 1] = α × s0, x0[n - 1] = α0 × s1, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n ≠ 0, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # x0 < n → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [n, n0]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, m

Proof step 194 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , x0[n0] = α0 × s1, (x0 + (⌜al⌝ ^ × sl0.last)')[n0] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , n = n0 + 1, ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n ≠ 0, n < 2 + # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ¬ # x0 < n → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) n < n0 ⊦ m + (* n) < m0 + (* n0) ↔ m < m0 + (n0 - n); (s) ⊦ m + 1 ≠ 0; (s)

Proof step 195 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (x0 + (⌜al⌝ ^ × sl0.last)')[n0] = α × s0, x0[n0] = α0 × s1, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , n0 ≤ # x0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), n0 < # x0 → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[Koenigs-Lemma-gen-behact], name:get-append-less, seq: ⊦ n < # x → (x + y)[n] = x[n], subst:[n, y, x] → [n0, (⌜al⌝ ^ × sl0.last)', x0], <all paths>

Additional information

Used simplifier rules: ⊦ m < n → m ≤ n; (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) ⊦ # x = 0 ↔ x = []; (s) ⊦ x ≠ [] → (a ' + x).last = x.last; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ finp(⌜x⌝ ); (s) Used terms: n0, (⌜al⌝ ^ × sl0.last)', x0

Proof step 196 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + y)[n] = x[n]

A spec-lemma

Proof step 197 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , x0[n0] = α0 × s1, (x0 + (⌜al⌝ ^ × sl0.last)')[n0] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), n0 ≤ # x0, ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ n0 < # x0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), n0 < # x0 → after(IOAut(startf, stepf))(α0, s1) ∧ α0 ≤ ⌜af⌝ ∧ finp(α0), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ after(IOAut(startf, stepf))(α, s0) ∧ α ≤ ⌜af⌝ ∧ finp(α)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s) ⊦ ¬ n < n; (s) ⊦ m ≤ m; (s) ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) ⊦ a '[0] = a; (s) ⊦ m - m = 0; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s)

Proof step 198 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , x0[# x0] = α0 × s1, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜al⌝ ^, sl0.last), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [sl0.last, ⌜al⌝ ^, stepf, startf], <all paths>

Additional information

Used terms: sl0.last, ⌜al⌝ ^, stepf, startf

Proof step 199 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 200 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , x0[# x0] = α0 × s1, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α, σ. ¬(α ^ = ⌜al⌝ ^ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ sl0.last = σ.l.last), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 201 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , x0[# x0] = α0 × s1, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. α ^ ≠ ⌜al⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ∨ ¬ finp(α) ∨ sl0.last ≠ σ.l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 16 terms: ⌜al⌝ , ⌜sl0⌝

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ .l = x; (s) Used terms: ⌜al⌝ , ⌜sl0⌝

Proof step 202 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ # x0 < n0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0])

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 203 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , n0 ≤ # x0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. n1 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n1], x0[n1]), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0])

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: n0 abort: F discard: T computed: F

Additional information

Used terms: n0

Proof step 204 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), n0 ≤ # x0, ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), n0 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0])

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: n0 ≠ # x0

Additional information

Used formulas: n0 ≠ # x0

Proof step 205 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, n0 ≠ # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , n0 ≤ # x0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), n0 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0])

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ n < # x → (x + a ')[n] = x[n]; (s) ⊦ m ≠ n → (m ≤ n ↔ m < n); (s)

Proof step 206 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x0.last, a ≠ τ, n0 ≠ # x0, x0 ≠ [], n0 < # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], x0[n0])

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[Koenigs-Lemma-gen-behact], name:get-append-less, seq: ⊦ n < # x → (x + y)[n] = x[n], subst:[n, y, x] → [n0, x0, _a0 '], <all paths>

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ a '[0] = a; (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ x ≠ [] → x[0] = x.head; (s) Used terms: n0, x0, _a0 '

Proof step 207 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + y)[n] = x[n]

A spec-lemma

Proof step 208 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x0.last, a ≠ τ, n0 ≠ # x0, x0 ≠ [], n0 < # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ n0 < # _a0 ', ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], x0[n0])

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)

Proof step 209 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x0.last, a ≠ τ, n0 ≠ # x0, n0 ≠ 0, x0 ≠ [], n0 < # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], x0[n0])

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[Koenigs-Lemma-gen-behact], name:get-append-less, seq: ⊦ n < # x → (x + y)[n] = x[n], subst:[n, y, x] → [n0, x0 + (⌜al⌝ ^ × sl0.last)', _a0 '], <all paths>

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] Used terms: n0, x0 + (⌜al⌝ ^ × sl0.last)', _a0 '

Proof step 210 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + y)[n] = x[n]

A spec-lemma

Proof step 211 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x0.last, a ≠ τ, n0 ≠ # x0, n0 ≠ 0, x0 ≠ [], n0 < # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ n0 < # _a0 ', ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], x0[n0])

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)

Proof step 212 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = x0.last, a ≠ τ, n0 ≠ # x0, n0 ≠ 0, x0 ≠ [], n0 < # x0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], x0[n0])

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[Koenigs-Lemma-gen-behact], name:get-butlast, seq: ⊦ n < # x → (x + a ')[n] = x[n], subst:[n, a, x] → [n0, ⌜al⌝ ^ × sl0.last, _a0 ' + x0], <all paths>

Additional information

Used simplifier rules: ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ m ≠ n → (m < n + 1 ↔ m < n); (s) ⊦ m ≠ n → (m < n ↔ ¬ n < m); (ss) ⊦ m < n → ¬ n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n0, ⌜al⌝ ^ × sl0.last, _a0 ' + x0

Proof step 213 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + a ')[n] = x[n]

A spec-lemma

Proof step 214 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , n0 = # x0, ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , n0 ≤ # x0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), n0 < # x0 → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0)[n0], x0[n0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) ((_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n0], (x0 + (⌜al⌝ ^ × sl0.last)')[n0])

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ (x + a ')[# x] = a; (s) ⊦ (a ' + x + y)[# x] = (a ' + x).last; (s) ⊦ ¬ n < n; (s) ⊦ m ≤ m; (s)

Proof step 215 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜al0⌝ × sl0[# al1], ⌜al⌝ ^ × sl0.last)

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen-basic[Koenigs-Lemma-gen-behact], name:edge-def, seq: ⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b), subst:[b, a, es, vs] → [⌜al⌝ ^ × sl0.last, ⌜al0⌝ × sl0[# al1], λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))], <all paths>

Additional information

Used terms: ⌜al⌝ ^ × sl0.last, ⌜al0⌝ × sl0[# al1], λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))

Proof step 216 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b)

A spec-lemma

Proof step 217 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (∃ a. actstream(⌜al⌝ ^ × sl0.last) = actstream(⌜al0⌝ × sl0[# al1]) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(⌜al0⌝ × sl0[# al1]), ⌜a '⌝ , endstate(⌜al⌝ ^ × sl0.last))) ∧ ( after(IOAut(startf, stepf))(actstream(⌜al0⌝ × sl0[# al1]), endstate(⌜al0⌝ × sl0[# al1])) ∧ actstream(⌜al0⌝ × sl0[# al1]) ≤ ⌜af⌝ ∧ finp(actstream(⌜al0⌝ × sl0[# al1]))) ∧ after(IOAut(startf, stepf))(actstream(⌜al⌝ ^ × sl0.last), endstate(⌜al⌝ ^ × sl0.last)) ∧ actstream(⌜al⌝ ^ × sl0.last) ≤ ⌜af⌝ ∧ finp(actstream(⌜al⌝ ^ × sl0.last))

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ endstate(ασ × st) = st; (s) ⊦ finp(⌜x⌝ ); (s)

Proof step 218 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , α2 ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (∃ a0. ⌜al⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ∧ move(IOAut(startf, stepf))(sl0[# al1], ⌜a0 '⌝ , sl0.last)) ∧ after(IOAut(startf, stepf))(⌜al0⌝ , sl0[# al1]) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ after(IOAut(startf, stepf))(⌜al⌝ ^, sl0.last)

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α2

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜x⌝ ≠ σ + ⌜nf0⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]

Proof step 219 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ + α2 = ⌜al⌝ , (_a0 ' + x0 + (⌜al⌝ ^ × sl0.last)')[n] = α × s0, α2 ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al⌝ ^ = ⌜al0⌝ + ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, α2 = ⌜al2⌝ , a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ), startf(sl0[0]), ⌜al⌝ ^ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ (∃ a0. ⌜al⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ∧ move(IOAut(startf, stepf))(sl0[# al1], ⌜a0 '⌝ , sl0.last)) ∧ after(IOAut(startf, stepf))(⌜al0⌝ , sl0[# al1]) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ after(IOAut(startf, stepf))(⌜al⌝ ^, sl0.last)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ σ0 + σ1 ≤ σ → (σ0 ≤ σ ↔ true); (ss) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ' = b ' ↔ a = b; (s) ⊦ x + y = x + z ↔ y = z; (s) ⊦ ⌜x⌝ + ⌜y⌝ = ⌜x0⌝ + ⌜z⌝ ↔ x + y = x0 + z; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s)

Proof step 220 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ move(IOAut(startf, stepf))(sl0[# al1], ⌜a '⌝ , sl0.last) ∧ after(IOAut(startf, stepf))(⌜al0⌝ , sl0[# al1]) ∧ after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last)

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: right 1

Additional information

Proof step 221 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ move(IOAut(startf, stepf))(sl0[# al1], ⌜a '⌝ , sl0.last), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:move, seq:⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β), subst:[stepf, startf, s2, β, s1] → [stepf, startf, sl0.last, ⌜a '⌝ , sl0[# al1]], <all paths>

Additional information

Used terms: sl0.last, ⌜a '⌝ , sl0[# al1], stepf, startf

Proof step 222 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)

A spec-lemma

Proof step 223 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, sl. ¬(frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ sl0[# al1] = sl[0] ∧ sl0.last = sl.last ∧ α ^ = ⌜a '⌝ ), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 224 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α0, sl. ¬ frag(IOAut(startf, stepf))(⌜sl⌝ , α0) ∨ ¬ finp(α0) ∨ sl0[# al1] ≠ sl[0] ∨ sl0.last ≠ sl.last ∨ α0 ^ ≠ ⌜a '⌝ , ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 14 terms: ⌜al2⌝ , sl0 from # al1 abort: F discard: T computed: F

Additional information

Used terms: ⌜al2⌝ , sl0 from # al1

Proof step 225 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ) ∨ ¬ finp(⌜al2⌝ ) ∨ sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last ∨ ⌜al2⌝ ^ ≠ ⌜a '⌝ , ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)

Proof step 226 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ¬ frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ) ∨ sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag-from-fin, seq:⊦ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ n < # al → (frag(IOAut(startf, stepf))(⌜sl from n⌝ , ⌜al from n⌝ ) ↔ true), subst:[al, stepf, sl, n, startf] → [al1 + al2, stepf, sl0, # al1, startf]

Additional information

Used terms: startf, stepf, sl0, al1 + al2, # al1

Proof step 227 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ n < # al → (frag(IOAut(startf, stepf))(⌜sl from n⌝ , ⌜al from n⌝ ) ↔ true)

A spec-lemma

Proof step 228 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1 + al2⌝ ) ∧ # al1 < #(al1 + al2) → (frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al1 + al2 from # al1⌝ ) ↔ true), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ) ∨ sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ a ' ≠ []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ x + y from # x = y; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 229 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:get-from-01, seq:m + m0 < # x ⊦ (x from m)[m0] = x[m + m0], subst:[m0, m, x] → [0, # al1, sl0], <all paths>

Additional information

Used terms: 0, # al1, sl0

Proof step 230 from proof lemma_2-5-2 (previous step) (back to tree)

m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]

A spec-lemma

Proof step 231 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ # al1 + 0 < # sl0, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 232 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf

Proof step 233 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 234 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜sl0⌝ = #(⌜al1⌝ + ⌜al2⌝ ) + ⌜1⌝ , (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), startf(sl0[0]), # sl0 ≤ # al1, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ n. ⌜n⌝ < #(⌜al1⌝ + ⌜al2⌝ ) → stepf(⌜sl0⌝ [n], (⌜al1⌝ + ⌜al2⌝ )[n], ⌜sl0⌝ [n +1]), sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n1⌝ + ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n1 + n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 235 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 + 1 = # sl0, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. n0 < # al1 + # al2 → stepf(sl0[n0], (al1 + al2)[n0], sl0[n0 + 1]), sl0[# al1] ≠ (sl0 from # al1)[0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 236 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, al2 ≠ [], # al1 + 0 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), sl0[# al1] ≠ sl0[# al1 + 0] ∨ sl0.last ≠ (sl0 from # al1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 237 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, sl0.last ≠ (sl0 from # al1).last, a ≠ τ, al2 ≠ [], sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(hd(sl0)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [sl0, s1, sl]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl0, s1, y

Proof step 238 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , sl0 = s1 + sl, ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, sl0.last ≠ (sl0 from # al1).last, a ≠ τ, al2 ≠ [], sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 from # al1⌝ , ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact]

Proof step 239 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, (s1 ' + sl).last ≠ (s1 ' + sl from # al1).last, a ≠ τ, al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 ' + sl from # al1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:append-from-gt, seq: ⊦ # x < n → x + y from n = y from (n - # x), subst:[n, y, x] → [# al1, sl, s1 '], <all paths>

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ x from 0 = x; (s) not-zero: 0 < n ⊦ (* n) ≤ m → m ≠ 0; (forward) from specification nat n ≠ 0 ⊦ (a ' + x)[(* n)] = x[n -1]; (s) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ a ' + x from 1 = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] Used terms: # al1, sl, s1 '

Proof step 240 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ # x < n → x + y from n = y from (n - # x)

A spec-lemma

Proof step 241 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, (s1 ' + sl).last ≠ (sl from (# al1 - # s1 ')).last, a ≠ τ, al2 ≠ [], # s1 ' < # al1, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl from (# al1 - # s1 ')⌝ , ⌜al2⌝ ), startf(s1), # al1 ≤ # sl, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ # a ' = 0 +1; (s)

Proof step 242 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, # al1 ≠ 1, (s1 ' + sl).last ≠ (sl from (# al1 - 1)).last, a ≠ τ, al1 ≠ [], al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl from (# al1 - 1)⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [# al1, n0]

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # al1, m

Proof step 243 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, # al1 ≠ 0, # al1 ≠ 1, (s1 ' + sl).last ≠ (sl from n0).last, a ≠ τ, al1 ≠ [], al2 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl from n0⌝ , ⌜al2⌝ ), startf(s1), # al1 ≤ # sl, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ # x = 0 ↔ x = []; (s)

Proof step 244 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl[n0] = (_a0 ' + x0).last, sl.last ≠ (sl from n0).last, a ≠ τ, al1 ≠ [], al2 ≠ [], n0 ≠ 0, sl ≠ [], n0 < # sl, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl from n0⌝ , ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply elim lemma

And closed the goal!

Rule argument

spec: list-last[IOstatestream], name:last-elim, seq:x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a ', subst:[x, a, y] → [sl, s2, sl0]

Additional information

Used simplifier rules: ⊦ x + a ' ≠ []; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ n ≤ # x → x + y from n = (x from n) + y; (s) ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: sl, s2, y

Proof step 245 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜al0⌝ , sl0[# al1]), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [sl0[# al1], ⌜al0⌝ , stepf, startf], <all paths>

Additional information

Used terms: sl0[# al1], ⌜al0⌝ , stepf, startf

Proof step 246 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 247 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. ¬(α ^ = ⌜al0⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ sl0[# al1] = σ.l.last), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 248 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α0, σ. α0 ^ ≠ ⌜al0⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ, α0) ∨ ¬ startf(σ[0]) ∨ ¬ finp(α0) ∨ sl0[# al1] ≠ σ.l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 14 terms: ⌜al1⌝ , ⌜sl0 to # al1 + 1⌝ abort: F discard: T computed: F

Additional information

Used terms: ⌜al1⌝ , ⌜sl0 to # al1 + 1⌝

Proof step 249 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ⌜al1⌝ ^ ≠ ⌜al0⌝ ∨ ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf(⌜sl0 to # al1 + 1⌝ [0]) ∨ ¬ finp(⌜al1⌝ ) ∨ sl0[# al1] ≠ ⌜sl0 to # al1 + 1⌝ .l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 250 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag-to, seq:⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n), subst:[stepf, n, α, σ, startf] → [stepf, # al1, ⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , startf]

Additional information

Used terms: startf, stepf, ⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ , # al1

Proof step 251 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → frag*(IOAut(startf, stepf))(σ to n + 1, α to n)

A spec-lemma

Proof step 252 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ) ∧ ¬ #(⌜al1⌝ + ⌜al2⌝ ) < ⌜# al1⌝ → frag*(IOAut(startf, stepf))(⌜sl0⌝ to # al1 + 1, ⌜al1⌝ + ⌜al2⌝ to # al1), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ) ∨ ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + σ to # x = ⌜x⌝ ; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ m + n < m; (s) ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 253 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:get-finto, seq:¬ # x < n, m < n ⊦ (x to n)[m] = x[m], subst:[m, n, x] → [0, # al1 + 1, sl0], <all paths>

Additional information

Used terms: 0, # al1 + 1, sl0

Proof step 254 from proof lemma_2-5-2 (previous step) (back to tree)

¬ # x < n, m < n ⊦ (x to n)[m] = x[m]

A spec-lemma

Proof step 255 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦ ¬ # sl0 < # al1 + 1 ∧ 0 < # al1 + 1

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s)

Proof step 256 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜al1⌝ + ⌜al2⌝ , ⌜sl0⌝ , stepf, startf

Proof step 257 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 258 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜sl0⌝ = #(⌜al1⌝ + ⌜al2⌝ ) + ⌜1⌝ , (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), # sl0 ≤ # al1, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. ⌜n⌝ < #(⌜al1⌝ + ⌜al2⌝ ) → stepf(⌜sl0⌝ [n], (⌜al1⌝ + ⌜al2⌝ )[n], ⌜sl0⌝ [n +1]), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n1⌝ + ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n1 + n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 259 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 + # al2 + 1 = # sl0, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # sl0 ≤ # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ n0. n0 < # al1 + # al2 → stepf(sl0[n0], (al1 + al2)[n0], sl0[n0 + 1]), ¬ startf((sl0 to # al1 + 1)[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 260 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, 0 < # al1 + 1, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ # sl0 < # al1 + 1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ¬ startf(sl0[0]) ∨ sl0[# al1] ≠ (sl0 to # al1 + 1).last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 261 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, sl0[# al1] ≠ (sl0 to # al1 + 1).last, a ≠ τ, sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(hd(sl0)), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [sl0, s1, sl]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl0, s1, y

Proof step 262 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , sl0 = s1 + sl, ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, sl0[# al1] ≠ (sl0 to # al1 + 1).last, a ≠ τ, sl0 ≠ [], # al1 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl0 to # al1 + 1⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x to n + 1 = a + (x to n); (s) ⊦ a ' + x ≠ []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact]

Proof step 263 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, (s1 ' + sl)[# al1] ≠ (s1 ' + (sl to # al1)).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl to # al1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , # al1 ≤ # sl, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:elim-fromto-fin, seq: ⊦ ¬ # x < n → (x0 = x to n ∧ x1 = x from n ↔ x = x0 + x1 ∧ # x0 = n), subst:[x, n, x0, x1] → [sl, # al1, sl0, sl1]

Additional information

Used simplifier rules: ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ ¬ # x < n → (x0 = x to n ∧ x1 = x from n ↔ x = x0 + x1 ∧ # x0 = n); (elim) Used terms: sl, # al1, sl0, sl1

Proof step 264 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , sl = sl0 + sl1, ⌜al0⌝ × (s1 ' + sl)[# al1] = (_a0 ' + x0).last, (s1 ' + sl)[# al1] ≠ (s1 ' + sl0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), # al1 ≤ # sl, ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ # sl < # al1, ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ m + n; (s) ⊦ m ≤ n → (n < m ↔ false); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ #(x + y) = # x + # y; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 265 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (s1 ' + sl0 + sl1)[# al1] = (_a0 ' + x0).last, (s1 ' + sl0 + sl1)[# al1] ≠ (s1 ' + sl0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:get-append-less, seq: ⊦ n < # x → (x + y)[n] = x[n], subst:[n, y, x] → [# al1, sl0 + sl1, s1 '], <all paths>

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] + σ = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ a '.last = a; (s) Used terms: # al1, sl0 + sl1, s1 '

Proof step 266 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n < # x → (x + y)[n] = x[n]

A spec-lemma

Proof step 267 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (s1 ' + sl0 + sl1)[# al1] = (_a0 ' + x0).last, (s1 ' + sl0 + sl1)[# al1] ≠ (s1 ' + sl0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ # al1 < # s1 ', ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s)

Proof step 268 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (sl0 + sl1)[# al1 - 1] = (_a0 ' + x0).last, (sl0 + sl1)[# al1 - 1] ≠ (s1 ' + sl0).last, a ≠ τ, al1 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [# al1, n0]

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # al1, m

Proof step 269 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al1, # al1 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (sl0 + sl1)[n0] = (_a0 ' + x0).last, # al1 ≠ 0, (sl0 + sl1)[n0] ≠ (s1 ' + sl0).last, a ≠ τ, al1 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s)

Proof step 270 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 = n0 + 1, # sl0 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (sl0 + sl1)[n0] = (_a0 ' + x0).last, (sl0 + sl1)[n0] ≠ (s1 ' + sl0).last, a ≠ τ, al1 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-last[IOstatestream], name:lapp, seq: ⊦ y ≠ [] → (x + y).last = y.last, subst:[y, x] → [sl0, s1 '], <all paths>

Additional information

Used simplifier rules: ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: sl0, s1 '

Proof step 271 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ y ≠ [] → (x + y).last = y.last

A spec-lemma

Proof step 272 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = n0 + 1, # al1 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (s1 ' + sl0 + sl1).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (sl0 + sl1)[n0] = (_a0 ' + x0).last, (sl0 + sl1)[n0] ≠ sl0.last, a ≠ τ, al1 ≠ [], sl0 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[Koenigs-Lemma-gen-behact] a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ y ≠ [] → (x + y + z).last = (y + z).last; (s)

Proof step 273 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 = n0 + 1, # sl0 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (sl0 + sl1).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × (sl0 + sl1)[n0] = (_a0 ' + x0).last, (sl0 + sl1)[n0] ≠ sl0.last, a ≠ τ, al1 ≠ [], sl0 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:get-append-grt, seq: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x], subst:[n, y, x] → [n0, sl1, sl0], <all paths>

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m = n + 1 → ¬ m ≤ n; (s) Used terms: n0, sl1, sl0

Proof step 274 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ¬ n < # x → (x + y)[n] = y[n - # x]

A spec-lemma

Proof step 275 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = n0 + 1, # al1 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (sl0 + sl1).last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × (sl0 + sl1)[n0] = (_a0 ' + x0).last, (sl0 + sl1)[n0] ≠ sl0.last, a ≠ τ, al1 ≠ [], sl0 ≠ [], n0 < # sl0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m + 1 ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ n < # x → (x + y)[n] = x[n]; (s)

Proof step 276 from proof lemma_2-5-2 (previous step) (back to tree)

# al1 = n0 + 1, # sl0 = n0 + 1, (_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × (sl0 + sl1).last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[n0] = (_a0 ' + x0).last, sl0[n0] ≠ sl0.last, a ≠ τ, al1 ≠ [], sl0 ≠ [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ + ⌜sl1⌝ , ⌜al1⌝ + ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜s1 '⌝ + ⌜sl0⌝ , ⌜al1⌝ ), startf(s1), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:get-last-nonempty, seq: ⊦ n = # x - 1 ∧ 0 < # x → x[n] = x.last, subst:[n, x] → [n0, sl0], <all paths>

Additional information

Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n0, sl0

Proof step 277 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ n = # x - 1 ∧ 0 < # x → x[n] = x.last

A spec-lemma

Proof step 278 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [sl0.last, ⌜al0⌝ + ⌜a '⌝ , stepf, startf], <all paths>

Additional information

Used terms: sl0.last, ⌜al0⌝ + ⌜a '⌝ , stepf, startf

Proof step 279 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 280 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ α, σ. ¬(α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ sl0.last = σ.l.last), ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 281 from proof lemma_2-5-2 (previous step) (back to tree)

(_a0 ' + x0 + ((⌜al0⌝ + ⌜a '⌝ ) × sl0.last)')[n] = α × s0, ⌜al2⌝ ^ = ⌜a '⌝ , ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ × sl0[# al1] = (_a0 ' + x0).last, a ≠ τ, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ + ⌜al2⌝ ), startf(sl0[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n1. ¬ # x0 < n1 → after(IOAut(startf, stepf))(actstream((_a0 ' + x0)[n1]), endstate((_a0 ' + x0)[n1])) ∧ actstream((_a0 ' + x0)[n1]) ≤ ⌜af⌝ ∧ finp(actstream((_a0 ' + x0)[n1])), ∀ α0, σ. α0 ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ frag(IOAut(startf, stepf))(σ, α0) ∨ ¬ startf(σ[0]) ∨ ¬ finp(α0) ∨ sl0.last ≠ σ.l.last, ∀ al1, startf, stepf, s, af. # al1 < #(al0 + a) → after(IOAut(startf, stepf))(⌜al1⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al1⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al1⌝ × s)) ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 14 terms: ⌜al1 + al2⌝ , ⌜sl0⌝ abort: F discard: T computed: F

Additional information

Used simplifier rules: ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ finp(⌜x⌝ ); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ .l = x; (s) Used terms: ⌜al1 + al2⌝ , ⌜sl0⌝

Proof step 282 from proof lemma_2-5-2 (previous step) (back to tree)

al ≠ [], after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s), ∃ al0, a. al0 + a = al

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s)

Proof step 283 from proof lemma_2-5-2 (previous step) (back to tree)

al ≠ [], after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ⌜al⌝ ≤ ⌜af⌝ , ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al0, startf, stepf, s, af. # al0 < # al → after(IOAut(startf, stepf))(⌜al0⌝ , s) ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ ⌜al0⌝ ≤ ⌜af⌝ ∧ ¬ trace(IOAut(startf, stepf))(⌜af⌝ ) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) → (∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al0⌝ × s)) ⊦ ∃ _a. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a) ∧ path ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (_a, ⌜al⌝ × s), ∃ al0, a. al0 + a ' = al

User applied rule exists right

And closed the goal!

Rule argument

pos: right 2 terms: al.butlast, al.last abort: F discard: T computed: F

Additional information

Used simplifier rules: x ≠ [] ⊦ x.butlast + x.last ' = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: al.butlast, al.last

Proof step 284 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ nf. isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(0)) ∧ pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 285 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), isroot ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(0)), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ ) ⊦

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 5

Additional information

Proof step 286 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ¬ trace(IOAut(startf, stepf))(⌜af⌝ ), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ ) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:trace, seq:⊦ trace(IOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ exec(IOAut(startf, stepf))(σ, β)), subst:[α, stepf, startf] → [⌜af⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜af⌝ , stepf, startf

Proof step 287 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ trace(IOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ exec(IOAut(startf, stepf))(σ, β))

A spec-lemma

Proof step 288 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ¬(⌜af⌝ = β ^ ∧ exec(IOAut(startf, stepf))(σ, β)), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)

Proof step 289 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), pathp ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ ) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen[Koenigs-Lemma-gen-behact], name:pathp-def, seq:⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1])), subst:[σ, g] → [⌜nf⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))], <all paths>

Additional information

Used terms: ⌜nf⌝ , (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))

Proof step 290 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ pathp(g)(σ) ↔ (∀ n. ⌜n⌝ < # σ → dom(g)(σ[n])) ∧ (∀ n. ⌜n + 1⌝ < # σ → edge(g)(σ[n], σ[n + 1]))

A spec-lemma

Proof step 291 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ n. ⌜n⌝ < # ⌜nf⌝ → dom ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ [n]), ∀ n. ⌜n + 1⌝ < # ⌜nf⌝ → edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜nf⌝ [n], ⌜nf⌝ [n + 1]), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ dom(vs × es) = vs; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ ≠ ∞; (s) ⊦ ⌜m⌝ + n∞ = ∞ ↔ n∞ = ∞; (s) ⊦ n∞ < ∞ ↔ n∞ ≠ ∞; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)

Proof step 292 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∃ sl, al, m. exec(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = ⌜af⌝ to m ∧ actstream(nf(0)) = ⌜al⌝ ^ ∧ endstate(nf(0)) = sl.last

Additional information

Used formulas: ∃ sl, al, m. exec(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = ⌜af⌝ to m ∧ actstream(nf(0)) = ⌜al⌝ ^ ∧ endstate(nf(0)) = sl.last

Proof step 293 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ sl, al, m. exec(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = ⌜af⌝ to m ∧ actstream(nf(0)) = ⌜al⌝ ^ ∧ endstate(nf(0)) = sl.last ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 294 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , actstream(nf(0)) = ⌜af to m⌝ , endstate(nf(0)) = sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(0), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(0), ασ, st

Proof step 295 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = α × s, s = sl.last, α = ⌜af to m⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 296 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∀ n. actstream(nf(n)) = ⌜af⌝ to m + n

Additional information

Used formulas: ∀ n. actstream(nf(n)) = ⌜af⌝ to m + n

Proof step 297 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af⌝ to m + n ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 298 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∀ n. ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = endstate(nf(n)) ∧ sl0.last = endstate(nf(n + 1)) ∧ ⌜al0⌝ ^ = ⌜af(n + m) '⌝ ^

Additional information

Used formulas: ∀ n. ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = endstate(nf(n)) ∧ sl0.last = endstate(nf(n + 1)) ∧ ⌜al0⌝ ^ = ⌜af(n + m) '⌝ ^

Proof step 299 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = endstate(nf(n)) ∧ sl0.last = endstate(nf(n + 1)) ∧ ⌜al0⌝ ^ = ⌜af(n + m) '⌝ ^ ⊦

User applied rule choice left

And obtained the following new goals

Rule argument

pos: left 12

Additional information

Proof step 300 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∀ n. ∃ m. # slf(n) = m

Additional information

Used formulas: ∀ n. ∃ m. # slf(n) = m

Proof step 301 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ n. ∃ m. # slf(n) = m ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 302 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: infinite-append[IOstatestream], name:infinite-append, seq:⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # lf(n) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # lf(n) = ⌜lf(n)⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → lf(m) = [] ∧ ii(m) = ii(n)) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) ), subst:[lf] → [λ n. (n = 0 ⊃ sl;tl(slf(n - 1)))]

Additional information

Used terms: λ n. (n = 0 ⊃ sl;tl(slf(n - 1)))

Proof step 303 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # lf(n) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # lf(n) = ⌜lf(n)⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → lf(m) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1))

A spec-lemma

Proof step 304 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 305 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: infinite-append[actionstream], name:infinite-append, seq:⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # lf(n) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # lf(n) = ⌜lf(n)⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → lf(m) = [] ∧ ii(m) = ii(n)) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) ), subst:[lf] → [λ n. (n = 0 ⊃ al;alf(n - 1))]

Additional information

Used terms: λ n. (n = 0 ⊃ al;alf(n - 1))

Proof step 306 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # lf(n) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # lf(n) = ⌜lf(n)⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → lf(m) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1))

A spec-lemma

Proof step 307 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∃ α, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii(n + 1)⌝ ∧ (α from ii(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ ) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(α) ⊃ ∃ n. # α = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 308 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1

Additional information

Used formulas: ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1

Proof step 309 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1 ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 14 terms: σ, α abort: F discard: T computed: F

Additional information

Used terms: σ, α

Proof step 310 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ⊦

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 18, left 19

Additional information

Proof step 311 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: startf(σ[0])

Additional information

Used formulas: startf(σ[0])

Proof step 312 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 313 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;;

Proof step 314 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, α = ⌜al0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ⌜x⌝ from n = ⌜x from n⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜al⌝ ^ ≠ ⌜af⌝ ; (s)

Proof step 315 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: ext, name:ext-trace-def, seq: ⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n])), subst:[α] → [⌜af⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝

Proof step 316 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n]))

A spec-lemma

Proof step 317 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ⌜n⌝ < # ⌜af⌝ → ext(⌜af⌝ [n]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ext(a) ↔ a ≠ τ; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 318 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: m1 + 1 abort: F discard: F computed: F

Additional information

Used terms: m1 + 1

Proof step 319 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 320 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 12 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 321 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ¬ ii0(m1) < ii0(m1 + 1), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 322 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), ii0(m1 + 1) ≤ ii0(m1), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 323 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 24 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 324 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), slf(m1).last = endstate(nf(m1 + 1)), slf(m1)[0] = endstate(nf(m1)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(σ[0]), startf(sl[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1 + 1), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1 + 1), ασ, st

Proof step 325 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), slf(m1).last = s, slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × s, (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 326 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), slf(m1)[0] = endstate(nf(m1)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), ii0(0) = 0, nf(m1 + 1) = α × slf(m1).last, nf(0) = ⌜af to m⌝ × sl.last, (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(σ[0]), startf(sl[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1), ασ, st

Proof step 327 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), slf(m1)[0] = s, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × s, (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 328 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), ii0(0) = 0, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, nf(0) = ⌜af to m⌝ × sl.last, (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , (al0 from ii0(m1)) to # (m1 = 0 ⊃ al;alf(m1 - 1)) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(σ[0]), startf(sl[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 12

Additional information

Proof step 329 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), m1 = 0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , (al0 from ii0(m1)) to # al = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ nf to 0 = []; (s) ⊦ x to 0 = []; (s) ⊦ nf to n = [] ↔ n = 0; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ [] ^ = []; (s) ⊦ # [] = 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m ≤ 0 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ x from 0 = x; (s) ⊦ σ from 0 = σ; (s) ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) ⊦ 0 ≤ m; (s)

Proof step 330 from proof lemma_2-5-2 (previous step) (back to tree)

sl.last = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(0) = 0, ii(1) = # sl, ii0(1) = 0, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = [] × sl.last, σ to # sl = ⌜sl⌝ , af(1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , []), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), startf(σ[0]), ¬ # σ < ⌜# sl⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [[], ⌜sl⌝ , stepf, startf], <all paths>

Additional information

Used terms: [], ⌜sl⌝ , stepf, startf

Proof step 331 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 332 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜sl⌝ = # [] + ⌜1⌝ , sl.last = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(1) = # sl, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × sl.last, nf(1) = α × slf(0).last, σ to # sl = ⌜sl⌝ , af(1) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ⌜n⌝ < # [] → stepf(⌜sl⌝ [n], [][n], ⌜sl⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # σ = ⌜0⌝ ↔ σ = []; (s) ⊦ n∞ < ⌜1⌝ ↔ n∞ = ⌜0⌝ ; (s) ⊦ ¬ n < 0; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 333 from proof lemma_2-5-2 (previous step) (back to tree)

# sl = 1, sl.last = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(1) = 1, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × sl.last, nf(1) = α × slf(0).last, σ to 1 = ⌜sl⌝ , af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0 ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-last[IOstatestream], name:last-elim, seq:x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a ', subst:[x, a, y] → [sl, s, sl0]

Additional information

Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ σ ≠ [] → σ to 1 ≠ []; (s) x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: sl, s, y

Proof step 334 from proof lemma_2-5-2 (previous step) (back to tree)

# sl = 1, ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = [] × s, s = slf(0)[0], sl = sl0 + s ', σ to 1 = ⌜sl⌝ , af(1) ≠ τ, sl ≠ [], σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ [] + x = x; (s) ⊦ a '[0] = a; (s) σ ≠ [] ⊦ σ to 1 = ⌜a '⌝ ↔ σ[0] = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ [] + σ = σ; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ x + a ' ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 335 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = [] × σ[0], af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 22 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 336 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = endstate(nf(0 + 1)), σ[0] = slf(0)[0], slf(0)[0] = endstate(nf(0)), ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(1) = 1, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × σ[0], nf(1) = α × slf(0).last, af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ , ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 337 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = endstate(nf(1)), σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(1) = 1, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × σ[0], nf(1) = α × endstate(nf(1)), af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ , ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0 ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(1), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(1), ασ, st

Proof step 338 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = s, σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α × s, nf(0) = [] × σ[0], nf(1) = α0 × s, af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws)

Proof step 339 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, ii(1) = 1, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × σ[0], nf(1) = α0 × slf(0).last, af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ , ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0 ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-one, seq: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ , subst:[a] → [af(0)], <all paths>

Additional information

Used terms: af(0)

Proof step 340 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝

A spec-lemma

Proof step 341 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ ^, af(0) = τ, ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α0 × slf(0).last, nf(0) = [] × σ[0], af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)

Proof step 342 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = [], af(0) = τ, ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α0 × slf(0).last, nf(0) = [] × σ[0], af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 18 terms: 0

Additional information

Used terms: 0

Proof step 343 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ , ii(0) = 0, ii(1) = 1, ii0(1) = 0, ii0(0) = 0, nf(1) = α0 × slf(0).last, nf(0) = [] × σ[0], af(0) ≠ τ, af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 344 from proof lemma_2-5-2 (previous step) (back to tree)

σ[0] = slf(0)[0], ⌜alf(0)⌝ ^ = ⌜af(0) '⌝ , ii(1) = 1, ii(0) = 0, ii0(0) = 0, ii0(1) = 0, nf(0) = [] × σ[0], nf(1) = α0 × slf(0).last, af(0) ≠ τ, af(1) ≠ τ, σ ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ σ[0] ';tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ σ[0] ';tl(slf(n - 1))) = ⌜(n = 0 ⊃ σ[0] ';tl(slf(n - 1)))⌝ , ∀ n. actstream(nf(n)) = ⌜af to n⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ [];alf(n - 1)) ∧ ii0(n + 1) = 0 ∧ ([] from ii0(n)) to # (n = 0 ⊃ [];alf(n - 1)) = (n = 0 ⊃ [];alf(n - 1)), ∀ m1. (m1 ≠ 0 → [] = alf(m1 - 1)) ∧ ii0(m1) = 0 ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 25 terms: 0 +1 abort: F discard: F computed: T

Additional information

Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a ' ≠ []; (s) Used terms: 0 +1

Proof step 345 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # (m1 = 0 ⊃ al;alf(m1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (σ from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = ⌜(m1 = 0 ⊃ sl;tl(slf(m1 - 1)))⌝ , (al0 from ii0(m1)) to # alf(m1 - 1) = (m1 = 0 ⊃ al;alf(m1 - 1)), af(m1 + 1) ≠ τ, m1 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 346 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(0) = 0, ii(m1 + 1) = ii(m1) + # tl(slf(m1 - 1)), ii0(m1 + 1) = ii0(m1) + # alf(m1 - 1), ii0(0) = 0, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, nf(0) = ⌜af to m⌝ × sl.last, (al0 from ii0(m1)) to # alf(m1 - 1) = alf(m1 - 1), (σ from ii(m1)) to # tl(slf(m1 - 1)) = ⌜tl(slf(m1 - 1))⌝ , af(m1 + 1) ≠ τ, m1 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(σ[0]), startf(sl[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [m1, m2]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: m1, m2

Proof step 347 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(m1 + 1) = ii(m1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(m1 + 1) = ii0(m1) + # alf(m2), m1 = m2 + 1, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (σ from ii(m1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , (al0 from ii0(m1)) to # alf(m2) = alf(m2), af(m1 + 1) ≠ τ, m1 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(m1 + 1) ≤ ii0(m1), ¬ # σ < ⌜ii(m1 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. af(n) ≠ τ, ∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ ii0(m1) < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x from # x = []; (s) ⊦ m < n → n ≠ 0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 348 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2 + 1)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 28 terms: m2 abort: F discard: T computed: F

Additional information

Used terms: m2

Proof step 349 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = endstate(nf(m2 + 1)), slf(m2)[0] = endstate(nf(m2)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(0) = 0, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii0(2 + m2) = # al0 + # alf(m2), ii0(0) = 0, nf(m2 + 1) = α0 × slf(m2 + 1)[0], nf(2 + m2) = α × slf(m2 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, [] to # alf(m2) = alf(m2), (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(σ[0]), startf(sl[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s)

Proof step 350 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], slf(m2)[0] = endstate(nf(m2)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(0) = 0, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii0(2 + m2) = # al0 + # alf(m2), ii0(0) = 0, nf(m2 + 1) = α0 × slf(m2).last, nf(2 + m2) = α × slf(m2 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, [] to # alf(m2) = alf(m2), (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(σ[0]), startf(sl[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0 ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m2), α1, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m2), ασ, st

Proof step 351 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], slf(m2)[0] = s, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × s, (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 352 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(0) = 0, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii0(2 + m2) = # al0 + # alf(m2), ii0(0) = 0, nf(m2) = α1 × slf(m2)[0], nf(m2 + 1) = α0 × slf(m2).last, nf(2 + m2) = α × slf(m2 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, [] to # alf(m2) = alf(m2), (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(σ[0]), startf(sl[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0 ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-one, seq: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ , subst:[a] → [af((m2 + 1) + m)], <all paths>

Additional information

Used terms: af((m2 + 1) + m)

Proof step 353 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝

A spec-lemma

Proof step 354 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af((m2 + 1) + m) = τ, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)

Proof step 355 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = [], af((m2 + 1) + m) = τ, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 28 terms: (m2 + 1) + m

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: (m2 + 1) + m

Proof step 356 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af((m2 + 1) + m) ≠ τ, af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 357 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(0) = 0, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii0(2 + m2) = # al0 + # alf(m2), ii0(0) = 0, nf(m2) = α1 × slf(m2)[0], nf(m2 + 1) = α0 × slf(m2).last, nf(2 + m2) = α × slf(m2 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, [] to # alf(m2) = alf(m2), (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , af((m2 + 1) + m) ≠ τ, af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(σ[0]), startf(sl[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0 ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-one, seq: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ , subst:[a] → [af(m2 + m)], <all paths>

Additional information

Used terms: af(m2 + m)

Proof step 358 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝

A spec-lemma

Proof step 359 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , af(m2 + m) = τ, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af((m2 + 1) + m) ≠ τ, af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)

Proof step 360 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2)⌝ ^ = [], af(m2 + m) = τ, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(2 + m2) ≠ τ, af((m2 + 1) + m) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 29 terms: m2 + m

Additional information

Used terms: m2 + m

Proof step 361 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(0) = 0, ii0(0) = 0, ii0(2 + m2) = # al0 + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m2) = α × slf(m2 + 1).last, nf(m2 + 1) = α0 × slf(m2).last, nf(m2) = α1 × slf(m2)[0], (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , [] to # alf(m2) = alf(m2), af(m2 + m) ≠ τ, af((m2 + 1) + m) ≠ τ, af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0, ∀ n. af(n) ≠ τ, ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 362 from proof lemma_2-5-2 (previous step) (back to tree)

# al0 = ii0(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ , ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ , ii(0) = 0, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii0(2 + m2) = # al0 + # alf(m2), ii0(0) = 0, nf(m2) = α1 × slf(m2)[0], nf(m2 + 1) = α0 × slf(m2).last, nf(2 + m2) = α × slf(m2 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, [] to # alf(m2) = alf(m2), (σ from ii(m2 + 1)) to # tl(slf(m2)) = ⌜tl(slf(m2))⌝ , af(m2 + m) ≠ τ, af((m2 + 1) + m) ≠ τ, af(2 + m2) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(σ[0]), startf(sl[0]), ii0(2 + m2) ≤ # al0, ¬ # σ < ⌜ii(2 + m2)⌝ , (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # al0 < ii0(n + 1) ∧ (al0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. af(n) ≠ τ, ∀ m1. m2 < m1 → alf(m1 - 1) = [] ∧ ii0(m1) = # al0 ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 36 terms: m2 + 1 abort: F discard: F computed: T

Additional information

Used simplifier rules: ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ n < n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a ' ≠ []; (s) Used terms: m2 + 1

Proof step 363 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, α = ⌜af0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 364 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(σ[0]), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;;

Proof step 365 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, σ = ⌜sl0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ⌜x⌝ from n = ⌜x from n⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜af⌝ ); (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 366 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: m0 +1 abort: F discard: F computed: T

Additional information

Used terms: m0 +1

Proof step 367 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl0[0]), startf(sl[0]), m0 ≤ m0 +1 → (m0 +1 = 0 ⊃ sl;tl(slf(m0 +1 - 1))) = [] ∧ ii(m0 +1) = ii(m0), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m +1 = m + 1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ m ≤ m + n; (s)

Proof step 368 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: m0 abort: F discard: F computed: F

Additional information

Used terms: m0

Proof step 369 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), slf(m0).last = endstate(nf(m0 + 1)), slf(m0)[0] = endstate(nf(m0)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 370 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), slf(m0).last = endstate(nf(m0 + 1)), slf(m0)[0] = endstate(nf(m0)), ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m0 + 1), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m0 + 1), ασ, st

Proof step 371 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), slf(m0).last = s, slf(m0)[0] = endstate(nf(m0)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × s, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 372 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), slf(m0)[0] = endstate(nf(m0)), ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(0) = 0, nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m0), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m0), ασ, st

Proof step 373 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), slf(m0)[0] = s, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × s, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 374 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 24 terms: m0 abort: F discard: F computed: F

Additional information

Used terms: m0

Proof step 375 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 376 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 19 terms: m0 abort: F discard: F computed: F

Additional information

Used terms: m0

Proof step 377 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), (sl0 from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ¬ ii(m0) < ii(m0 + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x to 0 = []; (s) ⊦ # [] = 0; (s) ⊦ m ≤ m; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m = m + n ↔ n = 0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 378 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: ext, name:ext-trace-def, seq: ⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n])), subst:[α] → [⌜af⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝

Proof step 379 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n]))

A spec-lemma

Proof step 380 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ⌜n⌝ < # ⌜af⌝ → ext(⌜af⌝ [n]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ext(a) ↔ a ≠ τ; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 381 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-one, seq: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ , subst:[a] → [af(m0 + m)], <all paths>

Additional information

Used terms: af(m0 + m)

Proof step 382 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝

A spec-lemma

Proof step 383 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ ^, af(m0 + m) = τ, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)

Proof step 384 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = [], af(m0 + m) = τ, ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 20 terms: m0 + m

Additional information

Used terms: m0 + m

Proof step 385 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ , ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), af(m0 + m) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 386 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), af(m0 + m) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. af(n) ≠ τ ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 7

Additional information

Used simplifier rules: ⊦ 0 ≤ m; (s) ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws) ⊦ nf from 0 = nf; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ frag(IOAut(startf, stepf))([], α); (s)

Proof step 387 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = [], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ , ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # alf(m0 - 1), nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m0)) = [], (af0 from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = (m0 = 0 ⊃ al;alf(m0 - 1)), af(m0 + m) ≠ τ, m0 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 388 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(m0 + 1) = ii(m0), ii0(m0 + 1) = ii0(m0) + # alf(m0 - 1), ii0(0) = 0, nf(m0) = α0 × slf(m0)[0], nf(m0 + 1) = α × slf(m0).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m0)) = [], tl(slf(m0 - 1)) = [], (af0 from ii0(m0)) to # alf(m0 - 1) = alf(m0 - 1), af(m0 + m) ≠ τ, m0 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [m0, m1]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: m0, m1

Proof step 389 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m0), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m0)⌝ ^ = ⌜af(m0 + m) '⌝ , ii(m0 + 1) = ii(m0), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # alf(m1), m0 = m1 + 1, nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α × slf(m0).last, nf(m0) = α0 × slf(m0)[0], tl(slf(m1)) = [], tl(slf(m0)) = [], (af0 from ii0(m0)) to # alf(m1) = alf(m1), af(m0 + m) ≠ τ, m0 ≠ 0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m0)⌝ , ⌜alf(m0)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ ii(m0) < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 390 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m1 + 1), ⌜alf(m1 + 1)⌝ ^ = ⌜af((m1 + 1) + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(2 + m1) = # sl0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1 + 1) = α0 × slf(m1 + 1)[0], nf(2 + m1) = α × slf(m1 + 1).last, nf(0) = ⌜af to m⌝ × sl.last, tl(slf(m1 + 1)) = [], tl(slf(m1)) = [], (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), af((m1 + 1) + m) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m1 + 1)⌝ , ⌜alf(m1 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sl0[0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # sl0 < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ m0. m1 < m0 → tl(slf(m0 - 1)) = [] ∧ ii(m0) = # sl0 ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-1, seq: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail), subst:[x, head, tail] → [slf(m1 + 1), s, sl1]

Additional information

Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ frag(IOAut(startf, stepf))([], α); (s) ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail); (elim) Used terms: slf(m1 + 1), head, tail

Proof step 391 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m1 + 1), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1 + 1)⌝ ^ = ⌜af((m1 + 1) + m) '⌝ , ii(2 + m1) = # sl0, ii(0) = 0, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m1) = α × slf(m1 + 1).last, nf(m1 + 1) = α0 × slf(m1 + 1)[0], sl1 = [], slf(m1 + 1) = s + sl1, tl(slf(m1)) = [], (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), af((m1 + 1) + m) ≠ τ, slf(m1 + 1) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1 + 1)⌝ , ⌜alf(m1 + 1)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m0. m1 < m0 → tl(slf(m0 - 1)) = [] ∧ ii(m0) = # sl0, ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # sl0 < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ a ' ≠ []; (s) ⊦ a '.last = a; (s) ⊦ hd(a ') = a; (s) ⊦ x ≠ [] → x[0] = hd(x); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) ⊦ a + x = a ' + x; (s)

Proof step 392 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii(m1 + 1), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m1 + 1)⌝ ^ = ⌜af((m1 + 1) + m) '⌝ , ii(2 + m1) = # sl0, ii(0) = 0, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × s, nf(0) = ⌜af to m⌝ × sl.last, nf(2 + m1) = α × s, slf(m1 + 1) = s ', tl(slf(m1)) = [], (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), af((m1 + 1) + m) ≠ τ, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜s '⌝ , ⌜alf(m1 + 1)⌝ ), startf(sl0[0]), startf(sl[0]), ∀ m0. m1 < m0 → tl(slf(m0 - 1)) = [] ∧ ii(m0) = # sl0, ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # sl0 < ii(n + 1) ∧ (sl0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(m1 + 1)⌝ , ⌜s '⌝ , stepf, startf], <all paths>

Additional information

Used simplifier rules: ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ m ≤ n → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ = n∞2); (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # x = 0 ↔ x = []; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a ' ≠ []; (s) Used terms: ⌜alf(m1 + 1)⌝ , ⌜s '⌝ , stepf, startf

Proof step 393 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 394 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, σ = ⌜sf0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, ⌜af0⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s)

Proof step 395 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: ext, name:ext-trace-def, seq: ⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n])), subst:[α] → [⌜af⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝

Proof step 396 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ext(α) ↔ (∀ n. ⌜n⌝ < # α → ext(α[n]))

A spec-lemma

Proof step 397 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ⌜n⌝ < # ⌜af⌝ → ext(⌜af⌝ [n]), ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ext(a) ↔ a ≠ τ; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 398 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ, ⌜af⌝ ≠ ⌜af0⌝ ^ ∨ ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ) ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 20

Additional information

Proof step 399 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜af0⌝ ^ = ⌜af⌝ ^

Additional information

Used formulas: ⌜af0⌝ ^ = ⌜af⌝ ^

Proof step 400 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ⌜af0⌝ ^ = ⌜af⌝ ^, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 2, flags: discard

Additional information

Proof step 401 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ ≠ ⌜af⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-nontau-01, seq:∀ m. ⌜m⌝ < # α → α[m] ≠ τ ⊦ α ^ = α, subst:[α] → [⌜af⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝

Proof step 402 from proof lemma_2-5-2 (previous step) (back to tree)

∀ m. ⌜m⌝ < # α → α[m] ≠ τ ⊦ α ^ = α

A spec-lemma

Proof step 403 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ ≠ ⌜af⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦ ∀ m. ⌜m⌝ < # ⌜af⌝ → ⌜af⌝ [m] ≠ τ

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s)

Proof step 404 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , af(m0) = τ, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ ≠ ⌜af⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 11 terms: m0

Additional information

Used terms: m0

Proof step 405 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af0⌝ ^ ≠ ⌜af⌝ ^, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜af⌝ = (⌜af⌝ to m) + (⌜af⌝ from m)

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ⌜nf to n⌝ + ⌜nf from n⌝ = ⌜nf⌝ ↔ true; (ss) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used formulas: ⌜af⌝ = (⌜af⌝ to m) + (⌜af⌝ from m)

Proof step 406 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ = (⌜af⌝ to m) + (⌜af⌝ from m), ⌜af0⌝ ^ ≠ ⌜af⌝ ^, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 407 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ⌜af⌝ = ⌜af to m⌝ + ⌜af from m⌝ , ⌜af0⌝ ^ ≠ ⌜af⌝ ^, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 18 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 408 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, ii0(0 + 1) = ii0(0) + # (0 = 0 ⊃ al;alf(0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, (af0 from ii0(0)) to # (0 = 0 ⊃ al;alf(0 - 1)) = (0 = 0 ⊃ al;alf(0 - 1)), ⌜af⌝ = ⌜af to m⌝ + ⌜af from m⌝ , ⌜af0⌝ ^ ≠ ⌜af⌝ ^, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ nf from 0 = nf; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 409 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × sl.last, af0 to # al = al, ⌜af⌝ = ⌜af to m⌝ + ⌜af from m⌝ , ⌜af0⌝ ^ ≠ ⌜af⌝ ^, ⌜af⌝ ≠ ⌜af0⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 7, flags: discard

Additional information

Proof step 410 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, af0 to # al = al, ⌜af to m⌝ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ (⌜af to m⌝ + ⌜af from m⌝ )^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af to m⌝ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)

Proof step 411 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × sl.last, af0 to # al = al, ⌜af to m⌝ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ ⌜af to m⌝ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af to m⌝ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Proof step 412 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al⌝ ^ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ ⌜al⌝ ^ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ α ^ ^ = α ^; (s)

Proof step 413 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al⌝ ^ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ ⌜al⌝ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜af0⌝ = (⌜af0⌝ to # al) + (⌜af0⌝ from # al)

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ⌜nf to n⌝ + ⌜nf from n⌝ = ⌜nf⌝ ↔ true; (ss) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used formulas: ⌜af0⌝ = (⌜af0⌝ to # al) + (⌜af0⌝ from # al)

Proof step 414 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af0⌝ = (⌜af0⌝ to # al) + (⌜af0⌝ from # al), ⌜al⌝ ^ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ ⌜al⌝ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ from n = ⌜nf from n⌝ ; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 415 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af0⌝ = ⌜al⌝ + ⌜af0 from # al⌝ , ⌜al⌝ ^ + ⌜af from m⌝ ≠ ⌜af0⌝ ^, ⌜af0⌝ ^ ≠ ⌜al⌝ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 6, flags: discard

Additional information

Proof step 416 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al⌝ ^ + ⌜af from m⌝ ≠ (⌜al⌝ + ⌜af0 from # al⌝ )^, (⌜al⌝ + ⌜af0 from # al⌝ )^ ≠ ⌜al⌝ ^ + ⌜af from m⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜al⌝ ^ ≠ ∞; (s) ⊦ σ + σ1 = σ + σ2 ↔ σ1 = σ2 ∨ # σ = ∞; (ws) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)

Proof step 417 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af0 from # al⌝ ^ ≠ ⌜af from m⌝ ^, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜af from m⌝ ^ = ⌜af0 from # al⌝ ^

Additional information

Used formulas: ⌜af from m⌝ ^ = ⌜af0 from # al⌝ ^

Proof step 418 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af0 from # al⌝ ^ ≠ ⌜af from m⌝ ^, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-equiv, seq:¬ finp(⌜af⌝ ^) ⊦ ⌜af⌝ ^ = ⌜af0⌝ ^ ↔ (∀ n. ∃ m. (⌜af⌝ to n)^ = (⌜af0⌝ to m)^), subst:[af0, af] → [af0 from # al, af from m], <all paths>

Additional information

Used terms: af0 from # al, af from m

Proof step 419 from proof lemma_2-5-2 (previous step) (back to tree)

¬ finp(⌜af⌝ ^) ⊦ ⌜af⌝ ^ = ⌜af0⌝ ^ ↔ (∀ n. ∃ m. (⌜af⌝ to n)^ = (⌜af0⌝ to m)^)

A spec-lemma

Proof step 420 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af0 from # al⌝ ^ ≠ ⌜af from m⌝ ^, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), finp(⌜af from m⌝ ^), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]

Proof step 421 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al0⌝ = ⌜af from m⌝ ^, ⌜af0 from # al⌝ ^ ≠ ⌜al0⌝ , ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-inf, seq: ⊦ finp(⌜af⌝ ^) ↔ (∃ n. ∀ m. n ≤ m → af(m) = τ), subst:[af] → [af from m]

Additional information

Used terms: af from m

Proof step 422 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ finp(⌜af⌝ ^) ↔ (∃ n. ∀ m. n ≤ m → af(m) = τ)

A spec-lemma

Proof step 423 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al0⌝ = ⌜af from m⌝ ^, ⌜af0 from # al⌝ ^ ≠ ⌜al0⌝ , ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), finp(⌜af from m⌝ ^) ↔ (∃ n. ∀ m0. n ≤ m0 → ((af from m))(m0) = τ), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ ((nf from n))(m) = nf(m + n); (s)

Proof step 424 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al0⌝ = ⌜af from m⌝ ^, ⌜af0 from # al⌝ ^ ≠ ⌜al0⌝ , ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ, ∀ m1. m0 ≤ m1 → af(m1 + m) = τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 24 terms: m0 +1 abort: F discard: T computed: T

Additional information

Used terms: m0 +1

Proof step 425 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al0⌝ = ⌜af from m⌝ ^, ⌜af0 from # al⌝ ^ ≠ ⌜al0⌝ , ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), m0 ≤ m0 +1 → af(m0 +1 + m) = τ, ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m +1 = m + 1; (s) c: ⊦ m + n = n + m; from specification nat-basic ⊦ m ≤ m + n; (s)

Proof step 426 from proof lemma_2-5-2 (previous step) (back to tree)

af((m0 + 1) + m) = τ, ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜al0⌝ = ⌜af from m⌝ ^, ⌜af0 from # al⌝ ^ ≠ ⌜al0⌝ , ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 24 terms: (m0 + 1) + m

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: (m0 + 1) + m

Proof step 427 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ¬ finp(⌜af from m⌝ ^), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∃ n. ¬(∃ m0. (⌜af from m⌝ to n)^ = (⌜af0 from # al⌝ to m0)^) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ = ⌜nf0⌝ ↔ nf = nf0; (s) ⊦ ¬ finp(⌜nf⌝ ); (s) stream-inf-forward: ⊦ ¬ finp(σ) → (∃ nf. ⌜nf⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ α ^ = ⌜af⌝ → (af(n) = τ ↔ false); (s) remtau-fin: ⊦ ¬ finp(α ^) → ¬ finp(α); (forward) from specification remtau ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 428 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af1⌝ = ⌜af from m⌝ ^, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦ ∃ m1. ⌜(af from m) to m0⌝ ^ = ⌜(af0 from # al) to m1⌝ ^

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: ii0(m0 + 1) - # al abort: F discard: T computed: F

Additional information

Used terms: ii0(m0 + 1) - # al

Proof step 429 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜al⌝ ^ × sl.last, af0 to # al = al, ⌜af1⌝ = ⌜af from m⌝ ^, ⌜(af from m) to m0⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m0 + 1) - # al)⌝ ^, ⌜af from m⌝ ≠ ⌜af0 from # al⌝ ^, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜al⌝ ^ + ⌜af from m⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) ⊦

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 1, left 3, left 4, left 5, left 6, left 8, left 9, left 10, left 11, left 12, left 13, left 14, left 16, left 18, left 20, left 21, left 22

Additional information

Proof step 430 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ⌜(af from m) to m0⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m0 + 1) - # al)⌝ ^, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule structural induction

And obtained the following new goals

Rule argument

indvar: m0

Additional information

Used simplifier rules: nat freely generated by 0, +1;; a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m - m = 0; (s) ⊦ nf to 0 = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s)

Proof step 431 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ⌜(af from m) to m1 +1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 +1 + 1) - # al)⌝ ^, ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ ii0, al, af, m, af0, alf, startf, stepf, slf, nf. ¬ ( ii0(1) = # al ∧ ⌜(af from m) to m1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ ∧ (∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1))) ∧ (∀ m, n. m ≤ n → ii0(m) ≤ ii0(n)) ∧ (∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m +1 = m + 1; (s)

Proof step 432 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ ii, al0, af1, m0, af2, alf0, startf0, stepf0, slf0, nf0. ii(1) ≠ # al0 ∨ ⌜(af1 from m0) to m1⌝ ^ = ⌜(af2 from # al0) to (ii(m1 + 1) - # al0)⌝ ^ ∨ ¬(∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ al0;alf0(n - 1)) ∧ (af2 from ii(n)) to # (n = 0 ⊃ al0;alf0(n - 1)) = (n = 0 ⊃ al0;alf0(n - 1))) ∨ ¬(∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∨ ¬ (∀ n0. frag(IOAut(startf0, stepf0))(⌜slf0(n0)⌝ , ⌜alf0(n0)⌝ ) ∧ slf0(n0)[0] = endstate(nf0(n0)) ∧ slf0(n0).last = endstate(nf0(n0 + 1)) ∧ ⌜alf0(n0)⌝ ^ = ⌜af1(n0 + m0) '⌝ ^) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 6 terms: ii0, al, af, m, af0, alf, startf, stepf, slf, nf abort: F discard: T computed: T

Additional information

Used terms: ii0, al, af, m, af0, alf, startf, stepf, slf, nf

Proof step 433 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ii0(1) ≠ # al ∨ ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ ∨ ¬(∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1))) ∨ ¬(∀ m, n. m ≤ n → ii0(m) ≤ ii0(n)) ∨ ¬ (∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 434 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 6 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 435 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = endstate(nf(m1 + 1)), slf(m1)[0] = endstate(nf(m1)), ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 436 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = endstate(nf(m1 + 1)), slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1 + 1), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1 + 1), ασ, st

Proof step 437 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = s, slf(m1)[0] = endstate(nf(m1)), ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, nf(m1 + 1) = α × s, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 438 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, nf(m1 + 1) = α × slf(m1).last, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1), ασ, st

Proof step 439 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1)[0] = s, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × s, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 440 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 8 terms: m1 + 1 abort: F discard: F computed: F

Additional information

Used terms: m1 + 1

Proof step 441 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, ii0((m1 + 1) + 1) = ii0(m1 + 1) + # (m1 + 1 = 0 ⊃ al;alf(m1 + 1 - 1)), nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (af0 from ii0(m1 + 1)) to # (m1 + 1 = 0 ⊃ al;alf(m1 + 1 - 1)) = (m1 + 1 = 0 ⊃ al;alf(m1 + 1 - 1)), ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 442 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), ⌜(af from m) to m1 + 1⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:to-unwind-end-inf, seq: ⊦ nf to m + 1 = (nf to m) + nf(m) ', subst:[m, nf] → [m1, af from m], <all paths>

Additional information

Used terms: m1, af from m

Proof step 443 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ nf to m + 1 = (nf to m) + nf(m) '

A spec-lemma

Proof step 444 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), ⌜((af from m) to m1) + ((af from m))(m1) '⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ ((nf from n))(m) = nf(m + n); (s)

Proof step 445 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ⌜(af from m) to m1⌝ ^ = ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^, ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), ⌜(af from m) to m1⌝ ^ + ⌜alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 2, flags: discard

Additional information

Proof step 446 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], (af0 from ii0(m1 + 1)) to # alf(m1) = alf(m1), ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 6, flags: rotate, discard

Additional information

Proof step 447 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + #((af0 from ii0(m1 + 1)) to # alf(m1)), nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ #(nf to n) = n; (s)

Proof step 448 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜af(m1 + m) '⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Proof step 449 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ = ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝

Additional information

Used formulas: ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ = ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝

Proof step 450 from proof lemma_2-5-2 (previous step) (back to tree)

⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ = ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ , ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s)

Proof step 451 from proof lemma_2-5-2 (previous step) (back to tree)

((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)) = (af0 from # al) to (ii0(2 + m1) - # al), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 1, flags: rotate, discard

Additional information

Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ σ + σ1 = σ + σ2 ↔ σ1 = σ2 ∨ # σ = ∞; (ws) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]

Proof step 452 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ , ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s)

Proof step 453 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, ((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)) ≠ (af0 from # al) to (ii0(2 + m1) - # al), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [(af0 from # al) to (ii0(2 + m1) - # al), ((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1))], <all paths>

Additional information

Used terms: (af0 from # al) to (ii0(2 + m1) - # al), ((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1))

Proof step 454 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 455 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), #(((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1))) ≠ #((af0 from # al) to (ii0(2 + m1) - # al)) ∨ (∃ n. ¬ ( n < #(((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1))) → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[n] = ((af0 from # al) to (ii0(2 + m1) - # al))[n])) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n → n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m < n ↔ ¬ n ≤ m; (ss) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ #(nf to n) = n; (s) ⊦ #(x + y) = # x + # y; (s)

Proof step 456 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(2 + m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, (ii0(m1 + 1) - # al) + # alf(m1) ≠ ii0(2 + m1) - # al ∨ ¬ ( m0 < (ii0(m1 + 1) - # al) + # alf(m1) → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] = af0(m0 + # al)) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 1, flags: discard

Additional information

Proof step 457 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) + # alf(m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), (ii0(m1 + 1) - # al) + # alf(m1) ≠ ii0(m1 + 1) + # alf(m1) - # al ∨ ¬ ( m0 < (ii0(m1 + 1) - # al) + # alf(m1) → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] = af0(m0 + # al)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: nat, name:prop-05, seq:m ≤ n ⊦ (n - m) + n0 = n + n0 - m, subst:[n0, m, n] → [# alf(m1), # al, ii0(m1 + 1)], <all paths>

Additional information

Used terms: # alf(m1), # al, ii0(m1 + 1)

Proof step 458 from proof lemma_2-5-2 (previous step) (back to tree)

m ≤ n ⊦ (n - m) + n0 = n + n0 - m

A spec-lemma

Proof step 459 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) + # alf(m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ¬ # al ≤ ii0(m1 + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, (ii0(m1 + 1) - # al) + # alf(m1) ≠ ii0(m1 + 1) + # alf(m1) - # al ∨ ¬ ( m0 < (ii0(m1 + 1) - # al) + # alf(m1) → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] = af0(m0 + # al)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 460 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) + # alf(m1) - # al)⌝ ^, al ≠ [], ii0(m1 + 1) < # al, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, (ii0(m1 + 1) - # al) + # alf(m1) ≠ ii0(m1 + 1) + # alf(m1) - # al ∨ ¬ ( m0 < (ii0(m1 + 1) - # al) + # alf(m1) → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] = af0(m0 + # al)) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 9 terms: 1, m1 + 1

Additional information

Used simplifier rules: ⊦ m ≤ m + n; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ¬ n < n; (s) Used terms: 1, m1 + 1

Proof step 461 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) + # alf(m1) - # al)⌝ ^, frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), # al ≤ ii0(m1 + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ii0(m1 + 1) + # alf(m1) - # al ≠ ii0(m1 + 1) + # alf(m1) - # al ∨ ¬ ( m0 < ii0(m1 + 1) + # alf(m1) - # al → (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] = af0(m0 + # al)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) n ≤ m ⊦ (m - n) + n0 = n1 ↔ m + n0 = n + n1; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s)

Proof step 462 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, nf(m1) = α0 × slf(m1)[0], nf(m1 + 1) = α × slf(m1).last, ⌜(af0 from # al) to (ii0(m1 + 1) - # al)⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to (ii0(m1 + 1) - # al) + # alf(m1)⌝ ^, ii0(m1 + 1) + # alf(m1) ≠ # al, (((af0 from # al) to (ii0(m1 + 1) - # al)) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] ≠ af0(m0 + # al), m0 < (ii0(m1 + 1) - # al) + # alf(m1), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), # al ≤ ii0(m1 + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-sub, seq:n ≤ m ⊦ n0 = m - n ↔ m = n0 + n, subst:[m, n, n0] → [ii0(m1 + 1), # al, n1]

Additional information

Used simplifier rules: n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: ii0(m1 + 1), # al, n1

Proof step 463 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ii0(m1 + 1) = n1 + # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to n1⌝ ^ + ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to n1 + # alf(m1)⌝ ^, ii0(m1 + 1) + # alf(m1) ≠ # al, (((af0 from # al) to n1) + ((af0 from ii0(m1 + 1)) to # alf(m1)))[m0] ≠ af0(m0 + # al), m0 < n1 + # alf(m1), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from ii0(m1 + 1)) to # alf(m1)⌝ ), # al ≤ ii0(m1 + 1), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ m + n; (s) ⊦ m < n → n ≠ 0; (s) ⊦ m = m + n ↔ n = 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 464 from proof lemma_2-5-2 (previous step) (back to tree)

ii0(1) = # al, ii0(m1 + 1) = n1 + # al, nf(m1 + 1) = α × slf(m1).last, nf(m1) = α0 × slf(m1)[0], ⌜(af0 from # al) to n1⌝ ^ + ⌜(af0 from n1 + # al) to # alf(m1)⌝ ^ ≠ ⌜(af0 from # al) to n1 + # alf(m1)⌝ ^, (((af0 from # al) to n1) + ((af0 from n1 + # al) to # alf(m1)))[m0] ≠ af0(m0 + # al), m0 < n1 + # alf(m1), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜(af0 from n1 + # al) to # alf(m1)⌝ ), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:get-append-grt, seq: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x], subst:[n, y, x] → [m0, (af0 from n1 + # al) to # alf(m1), (af0 from # al) to n1], <all paths>

Additional information

Used simplifier rules: ⊦ m ≤ n ↔ ¬ n < m; (ss) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n → (n ≤ m ↔ false); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ ((nf from n))(m) = nf(m + n); (s) ⊦ #(nf to n) = n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ n ≤ n0 → (m + (n0 - n)) + n = m + n0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n < # x → (x + y)[n] = x[n]; (s) ⊦ m ≤ n → (n < m ↔ false); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: m0, (af0 from n1 + # al) to # alf(m1), (af0 from # al) to n1

Proof step 465 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ¬ n < # x → (x + y)[n] = y[n - # x]

A spec-lemma

Proof step 466 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 12 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 467 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(0 + 1) = ii(0) + # (0 = 0 ⊃ sl;tl(slf(0 - 1))), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, (sf0 from ii(0)) to # (0 = 0 ⊃ sl;tl(slf(0 - 1))) = (0 = 0 ⊃ sl;tl(slf(0 - 1))), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ nf from 0 = nf; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 468 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ¬ frag(IOAut(startf, stepf))(⌜sf0⌝ , ⌜af0⌝ ), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜af0⌝ , ⌜sf0⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜af0⌝ , ⌜sf0⌝ , stepf, startf

Proof step 469 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 470 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , # ⌜sf0⌝ ≠ # ⌜af0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜af0⌝ → stepf(⌜sf0⌝ [n], ⌜af0⌝ [n], ⌜sf0⌝ [n +1]))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ + ∞ = ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 471 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 21 terms: m0 abort: F discard: T computed: F

Additional information

Used terms: m0

Proof step 472 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∃ m. ii(m) ≤ m0 ∧ m0 < ii(m + 1) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 473 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, ii(m1) < ii(m1 + 1), m0 < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 19 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 474 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, m0 < ii(m1 + 1), ii(m1) < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 21 terms: m1 + 1 abort: F discard: F computed: F

Additional information

Used terms: m1 + 1

Proof step 475 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, ii(m1) < ii(m1 + 1), m0 < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, m1 + 1 ≠ 0 → ii(m1 + 1) = ii0(m1 + 1) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≠ 0; (s)

Proof step 476 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(m1 + 1) = ii0(m1 + 1) + 1, ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, ii(m1) < ii(m1 + 1), m0 < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, m0 ≤ ii0(m1 + 1), ii(m1) ≤ ii0(m1 + 1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 477 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), m0 < ii(m1 + 1), ii(m1) < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m1) ≤ ii0(m1 + 1), m0 ≤ ii0(m1 + 1), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic

Proof step 478 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m1)) to # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) = (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) ≠ [], ii(m1) < ii(m1 + 1), m0 < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m1) ≤ ii0(m1 + 1), m0 ≤ ii0(m1 + 1), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 9

Additional information

Proof step 479 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii(m1 + 1) = ii0(m1 + 1) + 1, ii(1) = # sl, ii(0) = 0, ii0(0) = 0, m1 = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m1)) to # sl = (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) ≠ [], m0 < ii(m1 + 1), ii(m1) < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, m0 ≤ ii0(m1 + 1), ii(m1) ≤ ii0(m1 + 1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ 0 ≤ m; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ n + 0 = n; (s) ⊦ m < n → n ≠ 0; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ nf from 0 = nf; (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ x ≠ [] → x[0] = hd(x); (s)

Proof step 480 from proof lemma_2-5-2 (previous step) (back to tree)

# sl = ii0(1) + 1, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, sl ≠ [], m0 < # sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(hd(sl)), startf(sf0(0)), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [sl, s, sl0]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl, s, y

Proof step 481 from proof lemma_2-5-2 (previous step) (back to tree)

# sl = ii0(1) + 1, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sl = s + sl0, sf0 to # sl = sl, sl ≠ [], m0 < # sl, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(s), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ a + x = a ' + x; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s) ⊦ m + n = m + n0 ↔ n = n0; (s)

Proof step 482 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii0(1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = ii0(1) + 1, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s '⌝ + ⌜sl0⌝ , ⌜al⌝ ), startf(s), startf(sf0(0)), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 23 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 483 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii0(1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = ii0(1) + 1, ii(0) = 0, ii(0 + 1) = ii(0) + # (0 = 0 ⊃ s ' + sl0;tl(slf(0 - 1))), ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, (sf0 from ii(0)) to # (0 = 0 ⊃ s ' + sl0;tl(slf(0 - 1))) = (0 = 0 ⊃ s ' + sl0;tl(slf(0 - 1))), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s '⌝ + ⌜sl0⌝ , ⌜al⌝ ), startf(sf0(0)), startf(s), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ nf from 0 = nf; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)

Proof step 484 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii0(1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = ii0(1) + 1, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s '⌝ + ⌜sl0⌝ , ⌜al⌝ ), startf(s), startf(sf0(0)), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 485 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = ii0(1), ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = ii0(1) + 1, ii(0) = 0, ii0(0) = 0, ii0(0 + 1) = ii0(0) + # (0 = 0 ⊃ al;alf(0 - 1)), nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, (af0 from ii0(0)) to # (0 = 0 ⊃ al;alf(0 - 1)) = (0 = 0 ⊃ al;alf(0 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s '⌝ + ⌜sl0⌝ , ⌜al⌝ ), startf(sf0(0)), startf(s), m0 ≤ ii0(1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ nf from 0 = nf; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 486 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜s '⌝ + ⌜sl0⌝ , ⌜al⌝ ), startf(sf0(0)), startf(s), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜al⌝ , ⌜s '⌝ + ⌜sl0⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜al⌝ , ⌜s '⌝ + ⌜sl0⌝ , stepf, startf

Proof step 487 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 488 from proof lemma_2-5-2 (previous step) (back to tree)

#(⌜s '⌝ + ⌜sl0⌝ ) = # ⌜al⌝ + ⌜1⌝ , # sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. ⌜n⌝ < # ⌜al⌝ → stepf((⌜s '⌝ + ⌜sl0⌝ )[n], ⌜al⌝ [n], (⌜s '⌝ + ⌜sl0⌝ )[n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 489 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # al → stepf((s ' + sl0)[n], al[n], sl0[n]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 25 terms: m0 abort: F discard: T computed: F

Additional information

Used terms: m0

Proof step 490 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < # al → stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 491 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < # al → stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: m0 ≠ # al

Additional information

Used formulas: m0 ≠ # al

Proof step 492 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, m0 ≠ # al, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < # al → stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≠ n → (m ≤ n ↔ m < n); (s)

Proof step 493 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, al ≠ [], m0 ≠ # al, m0 < # al, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [s ' + sl0, sf0 to ii(1)], <all paths>

Additional information

Used terms: s ' + sl0, sf0 to ii(1)

Proof step 494 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 495 from proof lemma_2-5-2 (previous step) (back to tree)

#(sf0 to ii(1)) = #(s ' + sl0), # sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < # al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < #(sf0 to ii(1)) → (sf0 to ii(1))[n] = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)

Proof step 496 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < # al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 17 terms: m0 abort: F discard: F computed: F

Additional information

Used terms: m0

Proof step 497 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < # al, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < ii(1) → sf0(m0) = (s ' + sl0)[m0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: m0 < ii(1)

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n < m ↔ false); (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used formulas: m0 < ii(1)

Proof step 498 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < # al, m0 < ii(1), fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < ii(1) → sf0(m0) = (s ' + sl0)[m0], ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≠ n → (m < n + 1 ↔ m < n); (s) ⊦ m < n → n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 499 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0(m0) = (s ' + sl0)[m0], af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < ii(1), m0 < # al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf(sf0(m0), al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 19 terms: m0 + 1 abort: F discard: T computed: F

Additional information

Used terms: m0 + 1

Proof step 500 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0(m0) = (s ' + sl0)[m0], af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < # al, m0 < ii(1), fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), stepf(sf0(m0), al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 + 1 < ii(1) → sf0(m0 + 1) = (s ' + sl0)[m0 + 1], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s)

Proof step 501 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0(m0) = (s ' + sl0)[m0], sf0(m0 + 1) = sl0[m0], af0 to # al = al, al ≠ [], m0 ≠ # al, m0 < ii(1), m0 < # al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf(sf0(m0), al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sl0[m0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [al, af0 to # al], <all paths>

Additional information

Used terms: al, af0 to # al

Proof step 502 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 503 from proof lemma_2-5-2 (previous step) (back to tree)

#(af0 to # al) = # al, # sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0(m0 + 1) = sl0[m0], sf0(m0) = (s ' + sl0)[m0], al ≠ [], m0 ≠ # al, m0 < # al, m0 < ii(1), fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), stepf(sf0(m0), al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sl0[m0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. n < #(af0 to # al) → (af0 to # al)[n] = al[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 504 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0(m0) = (s ' + sl0)[m0], sf0(m0 + 1) = sl0[m0], al ≠ [], m0 ≠ # al, m0 < ii(1), m0 < # al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), stepf(sf0(m0), al[m0], sl0[m0]), ¬ stepf(sf0(m0), af0(m0), sl0[m0]), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # al → af0(n) = al[n] ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 29 terms: m0 abort: F discard: T computed: T

Additional information

Used terms: m0

Proof step 505 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, m0 = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), m0 ≤ # al, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 < # al → stepf((s ' + sl0)[m0], al[m0], sl0[m0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < n; (s) ⊦ m ≤ m; (s)

Proof step 506 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 21 terms: 0 abort: F discard: F computed: F

Additional information

Used terms: 0

Proof step 507 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(0).last = endstate(nf(0 + 1)), slf(0)[0] = endstate(nf(0)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(0 + m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 508 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(0).last = endstate(nf(1)), slf(0)[0] = (s ' + sl0).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × slf(0)[0], af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(1), α, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(1), ασ, st

Proof step 509 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(0).last = s0, slf(0)[0] = (s ' + sl0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × s0, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 510 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(0)[0] = (s ' + sl0).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = ⌜af to m⌝ × slf(0)[0], af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(0)⌝ , ⌜slf(0)⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜alf(0)⌝ , ⌜slf(0)⌝ , stepf, startf

Proof step 511 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 512 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜slf(0)⌝ = # ⌜alf(0)⌝ + ⌜1⌝ , # sl0 = # al, slf(0)[0] = (s ' + sl0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ⌜n⌝ < # ⌜alf(0)⌝ → stepf(⌜slf(0)⌝ [n], ⌜alf(0)⌝ [n], ⌜slf(0)⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 513 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = ⌜af to m⌝ × slf(0)[0], af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))) = (n = 0 ⊃ s ' + sl0;tl(slf(n - 1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 27 terms: 1 abort: F discard: T computed: F

Additional information

Used terms: 1

Proof step 514 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # al + 1, ii(0) = 0, ii(1 + 1) = ii(1) + # (1 = 0 ⊃ s ' + sl0;tl(slf(1 - 1))), ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # (1 = 0 ⊃ s ' + sl0;tl(slf(1 - 1))) = (1 = 0 ⊃ s ' + sl0;tl(slf(1 - 1))), fin(IOAut(startf, stepf)), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 515 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(0).last, nf(0) = ⌜af to m⌝ × slf(0)[0], (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 22 terms: 1 abort: F discard: T computed: F

Additional information

Used terms: 1

Proof step 516 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1).last = endstate(nf(1 + 1)), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = endstate(nf(1)), ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(0).last, sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 517 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1).last = endstate(nf(2)), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(2), α0, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(2), ασ, st

Proof step 518 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1).last = s0, slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × s0, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 519 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 27 terms: 1 abort: F discard: T computed: F

Additional information

Used terms: 1

Proof step 520 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(1) = # al, ii0(0) = 0, ii0(1 + 1) = ii0(1) + # (1 = 0 ⊃ al;alf(1 - 1)), nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, (af0 from ii0(1)) to # (1 = 0 ⊃ al;alf(1 - 1)) = (1 = 0 ⊃ al;alf(1 - 1)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 521 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], (af0 from # al) to # alf(0) = alf(0), sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [alf(0), (af0 from # al) to # alf(0)], <all paths>

Additional information

Used terms: alf(0), (af0 from # al) to # alf(0)

Proof step 522 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 523 from proof lemma_2-5-2 (previous step) (back to tree)

#((af0 from # al) to # alf(0)) = # alf(0), # sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. n < #((af0 from # al) to # alf(0)) → ((af0 from # al) to # alf(0))[n] = alf(0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 524 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(0) → af0(n + # al) = alf(0)[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 33 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 525 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), 0 < # alf(0) → af0(0 + # al) = alf(0)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 526 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), alf(0) ≠ [] → af0(# al) = hd(alf(0)), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 25

Additional information

Proof step 527 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, alf(0) = [], ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s)

Proof step 528 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af(m) = τ, alf(0) = [], ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(1) = # al, ii0(0) = 0, ii0(2) = # al, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 32 terms: m

Additional information

Used terms: m

Proof step 529 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), af0(# al), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 530 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, (sf0 from ii(1)) to # tl(slf(0)) = tl(slf(0)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [tl(slf(0)), (sf0 from ii(1)) to # tl(slf(0))], <all paths>

Additional information

Used terms: tl(slf(0)), (sf0 from ii(1)) to # tl(slf(0))

Proof step 531 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 532 from proof lemma_2-5-2 (previous step) (back to tree)

#((sf0 from ii(1)) to # tl(slf(0))) = # tl(slf(0)), # sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. n < #((sf0 from ii(1)) to # tl(slf(0))) → ((sf0 from ii(1)) to # tl(slf(0)))[n] = tl(slf(0))[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 533 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # tl(slf(0)) → sf0(n + ii(1)) = tl(slf(0))[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 33 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 534 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), 0 < # tl(slf(0)) → sf0(0 + ii(1)) = tl(slf(0))[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 535 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), tl(slf(0)) ≠ [] → sf0(ii(1)) = hd(tl(slf(0))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 25

Additional information

Proof step 536 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, tl(slf(0)) = [], af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # [] = 0; (s)

Proof step 537 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, tl(slf(0)) = [], af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-1, seq: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail), subst:[x, head, tail] → [slf(0), s0, sl]

Additional information

Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail); (elim) Used terms: slf(0), head, tail

Proof step 538 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sl = [], slf(0) = s0 + sl, sf0 to ii(1) = s ' + sl0, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ a ' ≠ []; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s) ⊦ hd(a ') = a; (s) ⊦ a '.last = a; (s) ⊦ x ≠ [] → x[0] = hd(x); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) ⊦ a + x = a ' + x; (s)

Proof step 539 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(1)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af(m) = τ, af0(# al) = hd([]), alf(0) = [], ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1), ii0(2) = # al, ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(1)[0], nf(2) = α0 × slf(1).last, slf(0) = slf(1)[0] ', af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd([]), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 31 terms: m

Additional information

Used terms: m

Proof step 540 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(tl(slf(0))), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(0) → stepf(slf(0)[n], alf(0)[n], slf(0)[n + 1]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 33 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 541 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # tl(slf(0)), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0(ii(1)) = hd(tl(slf(0))), sf0 to ii(1) = s ' + sl0, af0 to # al = al, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), 0 < # alf(0) → stepf(slf(0)[0], alf(0)[0], slf(0)[0 + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 542 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, slf(0)[0] = (s ' + sl0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # tl(slf(0)), ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × slf(0)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(tl(slf(0))), af0 to # al = al, sf0 to ii(1) = s ' + sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), alf(0) ≠ [] → stepf(slf(0)[0], hd(alf(0)), slf(0)[1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-1, seq: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail), subst:[x, head, tail] → [slf(0), s0, sl]

Additional information

Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail); (elim) Used terms: slf(0), head, tail

Proof step 543 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(0)[0] = (s ' + sl0).last, slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × slf(0)[0], nf(1) = α × slf(1)[0], sf0(ii(1)) = hd(sl), slf(0) = s0 + sl, sf0 to ii(1) = s ' + sl0, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), ¬ stepf(sf0(# al), hd(alf(0)), sf0(ii(1))), alf(0) ≠ [] → stepf(slf(0)[0], hd(alf(0)), slf(0)[1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ a + x = a ' + x; (s)

Proof step 544 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), hd(slf(0)) = (s ' + sl0).last, ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × hd(slf(0)), nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), slf(0) = s0 ' + sl, af0 to # al = al, sf0 to ii(1) = s ' + sl0, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), s0 ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf(hd(slf(0)), hd(alf(0)), slf(0)[1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [slf(0), s1, sl1]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: slf(0), s1, y

Proof step 545 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × s1, nf(1) = α × slf(1)[0], s1 = (s ' + sl0).last, sf0(ii(1)) = hd(sl), slf(0) = s0 ' + sl, slf(0) = s1 + sl1, sf0 to ii(1) = s ' + sl0, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), s0 ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf(s1, hd(alf(0)), slf(0)[1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] eq-05: ⊦ x = a ' + y ∧ x = b ' + z → a = b ∧ y = z; (forward) from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ a + x = a ' + x; (s)

Proof step 546 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, nf(1) = α × slf(1)[0], sf0(ii(1)) = hd(sl), slf(0) = (s ' + sl0).last ' + sl, sf0 to ii(1) = s ' + sl0, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), (s ' + sl0).last ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0).last, hd(alf(0)), slf(0)[1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [s ' + sl0, sf0 to ii(1)], <all paths>

Additional information

Used terms: s ' + sl0, sf0 to ii(1)

Proof step 547 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 548 from proof lemma_2-5-2 (previous step) (back to tree)

#(sf0 to ii(1)) = #(s ' + sl0), # sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × (s ' + sl0).last, nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), slf(0) = (s ' + sl0).last ' + sl, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), (s ' + sl0).last ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0).last, hd(alf(0)), slf(0)[1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < #(sf0 to ii(1)) → (sf0 to ii(1))[n] = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)

Proof step 549 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × (s ' + sl0).last, nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), slf(0) = (s ' + sl0).last ' + sl, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), (s ' + sl0).last ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0).last, hd(alf(0)), slf(0)[1]), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 28 terms: # al abort: F discard: F computed: F

Additional information

Used terms: # al

Proof step 550 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × (s ' + sl0).last, nf(1) = α × slf(1)[0], sf0(ii(1)) = hd(sl), slf(0) = (s ' + sl0).last ' + sl, af0 to # al = al, slf(0) ≠ [], fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), (s ' + sl0).last ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0).last, hd(alf(0)), slf(0)[1]), # al < ii(1) → sf0(# al) = (s ' + sl0)[# al], ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ m; (s) ⊦ m < n → n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m = n + 1 → ¬ m ≤ n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 551 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × (s ' + sl0).last, nf(2) = α0 × slf(1).last, sf0(# al) = (s ' + sl0)[# al], sf0(ii(1)) = hd(sl), slf(0) = (s ' + sl0).last ' + sl, af0 to # al = al, slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), (s ' + sl0).last ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0).last, hd(alf(0)), slf(0)[1]), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:at-last, seq: ⊦ x ≠ [] → x[# x - 1] = x.last, subst:[x] → [s ' + sl0], <rotated> <all paths>

Additional information

Used simplifier rules: ⊦ x + y = [] ↔ x = [] ∧ y = []; (as) ⊦ a ' ≠ []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] Used terms: s ' + sl0

Proof step 552 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x ≠ [] → x[# x - 1] = x.last

A spec-lemma

Proof step 553 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(2) = α0 × slf(1).last, nf(0) = ⌜af to m⌝ × (s ' + sl0)[#(s ' + sl0) - 1], nf(1) = α × slf(1)[0], sf0(ii(1)) = hd(sl), sf0(# al) = (s ' + sl0)[# al], slf(0) = (s ' + sl0)[#(s ' + sl0) - 1] ' + sl, af0 to # al = al, s ' + sl0 ≠ [], slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), (s ' + sl0)[#(s ' + sl0) - 1] ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf((s ' + sl0)[#(s ' + sl0) - 1], hd(alf(0)), slf(0)[1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s)

Proof step 554 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(0) = ⌜af to m⌝ × sf0(# al), nf(1) = α × slf(1)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), sf0(# al) = (s ' + sl0)[# al], slf(0) = sf0(# al) ' + sl, af0 to # al = al, slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), sf0(# al) ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), alf(0) ≠ [] → stepf(sf0(# al), hd(alf(0)), slf(0)[1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 29

Additional information

Proof step 555 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), alf(0) = [], ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(2) = α0 × slf(1).last, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × sf0(# al), sf0(# al) = (s ' + sl0)[# al], sf0(ii(1)) = hd(sl), slf(0) = sf0(# al) ' + sl, af0 to # al = al, slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), sf0(# al) ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # [] = 0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x = x + y ↔ y = []; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic onein: ⊦ # x = 1 ∧ a ∈ x → x = a '; (forward) from specification list[IOstatestream] ⊦ # [] = 0; (s) ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s)

Proof step 556 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af(m) = τ, af0(# al) = hd([]), alf(0) = [], ii(2) = ii(1), ii(0) = 0, ii(1) = # al + 1, ii0(2) = # al, ii0(1) = # al, ii0(0) = 0, nf(2) = α0 × slf(1).last, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × sf0(# al), sf0(# al) = (s ' + sl0)[# al], sf0(ii(1)) = hd([]), slf(0) = sf0(# al) ', af0 to # al = al, slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), sf0(# al) ∈ slf(0), ¬ stepf(sf0(# al), hd([]), hd([])), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 37 terms: m

Additional information

Used terms: m

Proof step 557 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = # slf(0), slf(1)[0] = slf(0).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # alf(0), ii0(1) = # al, ii0(0) = 0, nf(2) = α0 × slf(1).last, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × sf0(# al), sf0(# al) = (s ' + sl0)[# al], sf0(ii(1)) = hd(sl), slf(0) = sf0(# al) ' + sl, af0 to # al = al, slf(0) ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), stepf(sf0(# al), hd(alf(0)), slf(0)[1]), sf0(# al) ∈ slf(0), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 19, flags: discard

Additional information

Proof step 558 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) + 1 = #(sf0(# al) ' + sl), slf(1)[0] = (sf0(# al) ' + sl).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # alf(0), nf(0) = ⌜af to m⌝ × sf0(# al), nf(1) = α × slf(1)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), sf0(# al) = (s ' + sl0)[# al], af0 to # al = al, sf0(# al) ' + sl ≠ [], # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), stepf(sf0(# al), hd(alf(0)), (sf0(# al) ' + sl)[1]), sf0(# al) ∈ sf0(# al) ' + sl, ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] n ≠ 0 ⊦ (a ' + x)[(* n)] = x[n -1]; (s) ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a ' + x ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)

Proof step 559 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, # alf(0) = # sl, slf(1)[0] = (sf0(# al) ' + sl).last, ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, af0(# al) = hd(alf(0)), ii(0) = 0, ii(1) = # al + 1, ii(2) = ii(1) + # sl, ii0(2) = # al + # sl, ii0(1) = # al, ii0(0) = 0, nf(2) = α0 × slf(1).last, nf(1) = α × slf(1)[0], nf(0) = ⌜af to m⌝ × sf0(# al), sf0(# al) = (s ' + sl0)[# al], sf0(ii(1)) = hd(sl), af0 to # al = al, # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(s), startf(sf0(0)), stepf(sf0(# al), hd(alf(0)), sl[0]), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: sl

Additional information

Used simplifier rules: statelist freely generated by [], +;; a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a + x = a ' + x; (s) ⊦ hd(a ' + x) = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream]

Proof step 560 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(0) = # sl, # sl0 = # al, slf(1)[0] = (sf0(# al) ' + sl).last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af0(# al) = hd(alf(0)), ii(2) = ii(1) + # sl, ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al + # sl, nf(0) = ⌜af to m⌝ × sf0(# al), nf(1) = α × slf(1)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd(sl), sf0(# al) = (s ' + sl0)[# al], sl = [], af0 to # al = al, # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), stepf(sf0(# al), hd(alf(0)), sl[0]), ¬ stepf(sf0(# al), hd(alf(0)), hd(sl)), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 561 from proof lemma_2-5-2 (previous step) (back to tree)

# sl0 = # al, slf(1)[0] = (s ' + sl0)[# al], slf(1)[0] = sf0(# al), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(1)⌝ ^ = ⌜af(1 + m) '⌝ ^, af(m) = τ, af0(# al) = hd([]), alf(0) = [], ii(2) = ii(1), ii(1) = # al + 1, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, ii0(2) = # al, nf(0) = ⌜af to m⌝ × slf(1)[0], nf(1) = α × slf(1)[0], nf(2) = α0 × slf(1).last, sf0(ii(1)) = hd([]), af0 to # al = al, # al < ii(1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(1)⌝ , ⌜alf(1)⌝ ), startf(sf0(0)), startf(s), stepf(slf(1)[0], hd([]), [][0]), ¬ stepf(slf(1)[0], hd([]), hd([])), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < ii(1) → sf0(n) = (s ' + sl0)[n] ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 27 terms: m

Additional information

Used terms: m

Proof step 562 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(m1 + 1) = ii(m1) + # (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), ii(m1 + 1) = ii0(m1 + 1) + 1, ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m1)) to # tl(slf(m1 - 1)) = (m1 = 0 ⊃ sl;tl(slf(m1 - 1))), (m1 = 0 ⊃ sl;tl(slf(m1 - 1))) ≠ [], m1 ≠ 0, m0 < ii(m1 + 1), ii(m1) < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, m0 ≤ ii0(m1 + 1), ii(m1) ≤ ii0(m1 + 1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m1 ≠ 0 → ii(m1) = ii0(m1) + 1, ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic

Proof step 563 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(m1) = ii0(m1) + 1, ii(m1 + 1) = ii(m1) + # tl(slf(m1 - 1)), ii(m1 + 1) = ii0(m1 + 1) + 1, ii(1) = # sl, ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m1)) to # tl(slf(m1 - 1)) = tl(slf(m1 - 1)), m1 ≠ 0, tl(slf(m1 - 1)) ≠ [], m0 < ii(m1 + 1), ii(m1) < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m1) ≤ m0, m0 ≤ ii0(m1 + 1), ii(m1) ≤ ii0(m1 + 1), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [m1, m2]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: m1, m2

Proof step 564 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(m1 + 1) = ii(m1) + # tl(slf(m2)), ii(m1) = ii0(m1) + 1, ii0(0) = 0, m1 = m2 + 1, nf(0) = ⌜af to m⌝ × sl.last, (sf0 from ii(m1)) to # tl(slf(m2)) = tl(slf(m2)), sf0 to # sl = sl, m1 ≠ 0, tl(slf(m2)) ≠ [], ii(m1) < ii(m1 + 1), m0 < ii(m1 + 1), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m1) ≤ ii0(m1 + 1), m0 ≤ ii0(m1 + 1), ii(m1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m < n → n ≠ 0; (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m + 1 ≠ 0; (s)

Proof step 565 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 28 terms: m2 + 1 abort: F discard: F computed: F

Additional information

Used terms: m2 + 1

Proof step 566 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0((m2 + 1) + 1) = ii0(m2 + 1) + # (m2 + 1 = 0 ⊃ al;alf(m2 + 1 - 1)), nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), (af0 from ii0(m2 + 1)) to # (m2 + 1 = 0 ⊃ al;alf(m2 + 1 - 1)) = (m2 + 1 = 0 ⊃ al;alf(m2 + 1 - 1)), tl(slf(m2)) ≠ [], m0 < ii(2 + m2), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m2 + 1) ≤ m0, m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 567 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, (af0 from ii0(m2 + 1)) to # alf(m2) = alf(m2), (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [alf(m2), (af0 from ii0(m2 + 1)) to # alf(m2)], <all paths>

Additional information

Used terms: alf(m2), (af0 from ii0(m2 + 1)) to # alf(m2)

Proof step 568 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 569 from proof lemma_2-5-2 (previous step) (back to tree)

#((af0 from ii0(m2 + 1)) to # alf(m2)) = # alf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), tl(slf(m2)) ≠ [], m0 < ii(2 + m2), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m2 + 1) ≤ m0, m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < #((af0 from ii0(m2 + 1)) to # alf(m2)) → ((af0 from ii0(m2 + 1)) to # alf(m2))[n] = alf(m2)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 570 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(m2) → af0(n + ii0(m2 + 1)) = alf(m2)[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 33 terms: m0 - ii0(m2 + 1) abort: F discard: T computed: F

Additional information

Used terms: m0 - ii0(m2 + 1)

Proof step 571 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, (sf0 from ii(m2 + 1)) to # tl(slf(m2)) = tl(slf(m2)), tl(slf(m2)) ≠ [], m0 < ii(2 + m2), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m2 + 1) ≤ m0, m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [tl(slf(m2)), (sf0 from ii(m2 + 1)) to # tl(slf(m2))], <all paths>

Additional information

Used terms: tl(slf(m2)), (sf0 from ii(m2 + 1)) to # tl(slf(m2))

Proof step 572 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 573 from proof lemma_2-5-2 (previous step) (back to tree)

#((sf0 from ii(m2 + 1)) to # tl(slf(m2))) = # tl(slf(m2)), ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < #((sf0 from ii(m2 + 1)) to # tl(slf(m2))) → ((sf0 from ii(m2 + 1)) to # tl(slf(m2)))[n] = tl(slf(m2))[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 574 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, tl(slf(m2)) ≠ [], m0 < ii(2 + m2), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m2 + 1) ≤ m0, m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # tl(slf(m2)) → sf0(n + ii(m2 + 1)) = tl(slf(m2))[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 33 terms: m0 - ii(m2 + 1) abort: F discard: F computed: F

Additional information

Used terms: m0 - ii(m2 + 1)

Proof step 575 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], m0 - ii(m2 + 1) < # tl(slf(m2)) → sf0((m0 - ii(m2 + 1)) + ii(m2 + 1)) = tl(slf(m2))[m0 - ii(m2 + 1)], ∀ n. n < # tl(slf(m2)) → sf0(n + ii(m2 + 1)) = tl(slf(m2))[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 576 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, sf0((m0 - ii(m2 + 1)) + ii(m2 + 1)) = tl(slf(m2))[m0 - ii(m2 + 1)], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), m0 < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ m0, ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], ∀ n. n < # tl(slf(m2)) → sf0(n + ii(m2 + 1)) = tl(slf(m2))[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-sub, seq:n ≤ m ⊦ n0 = m - n ↔ m = n0 + n, subst:[m, n, n0] → [m0, ii(m2 + 1), n1]

Additional information

Used simplifier rules: n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: m0, ii(m2 + 1), n1

Proof step 577 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, m0 = n1 + ii(m2 + 1), nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], m0 < ii(2 + m2), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), ii(m2 + 1) ≤ m0, m0 ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sf0(m0), af0(m0), sf0(m0 + 1)), m0 - ii0(m2 + 1) < # alf(m2) → af0((m0 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[m0 - ii0(m2 + 1)], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # tl(slf(m2)) → sf0(n + ii(m2 + 1)) = tl(slf(m2))[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m ≤ m + n; (s)

Proof step 578 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # tl(slf(m2)) → sf0(n + ii(m2 + 1)) = tl(slf(m2))[n], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 23 terms: n1 + 1 abort: F discard: T computed: F

Additional information

Used terms: n1 + 1

Proof step 579 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 31 terms: m2 + 1 abort: F discard: F computed: F

Additional information

Used terms: m2 + 1

Proof step 580 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m2 + 1).last = endstate(nf((m2 + 1) + 1)), slf(m2 + 1)[0] = endstate(nf(m2 + 1)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 581 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m2 + 1).last = endstate(nf(2 + m2)), slf(m2 + 1)[0] = endstate(nf(m2 + 1)), ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m2 + 1), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m2 + 1), ασ, st

Proof step 582 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m2 + 1).last = endstate(nf(2 + m2)), slf(m2 + 1)[0] = s, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 583 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m2 + 1).last = endstate(nf(2 + m2)), ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(2 + m2), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(2 + m2), ασ, st

Proof step 584 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m2 + 1).last = s, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(2 + m2) = α0 × s, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 585 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2 + 1)⌝ , ⌜alf(m2 + 1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(m2 + 1)⌝ , ⌜slf(m2 + 1)⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜alf(m2 + 1)⌝ , ⌜slf(m2 + 1)⌝ , stepf, startf

Proof step 586 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 587 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜slf(m2 + 1)⌝ = # ⌜alf(m2 + 1)⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. ⌜n⌝ < # ⌜alf(m2 + 1)⌝ → stepf(⌜slf(m2 + 1)⌝ [n], ⌜alf(m2 + 1)⌝ [n], ⌜slf(m2 + 1)⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 588 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 35 terms: m2 abort: F discard: F computed: F

Additional information

Used terms: m2

Proof step 589 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = endstate(nf(m2 + 1)), slf(m2)[0] = endstate(nf(m2)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s)

Proof step 590 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], slf(m2)[0] = endstate(nf(m2)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m2), α1, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m2), ασ, st

Proof step 591 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], slf(m2)[0] = s, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 592 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(m2) = α1 × slf(m2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2)⌝ , ⌜alf(m2)⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(m2)⌝ , ⌜slf(m2)⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜alf(m2)⌝ , ⌜slf(m2)⌝ , stepf, startf

Proof step 593 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 594 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜slf(m2)⌝ = # ⌜alf(m2)⌝ + ⌜1⌝ , # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2) = α1 × slf(m2)[0], sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. ⌜n⌝ < # ⌜alf(m2)⌝ → stepf(⌜slf(m2)⌝ [n], ⌜alf(m2)⌝ [n], ⌜slf(m2)⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 595 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(m2) = α1 × slf(m2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(m2) → stepf(slf(m2)[n], alf(m2)[n], slf(m2)[n + 1]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 43 terms: n1 + 1 abort: F discard: T computed: F

Additional information

Used terms: n1 + 1

Proof step 596 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2) = α1 × slf(m2)[0], sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # tl(slf(m2)), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + 1 < # alf(m2) → stepf(slf(m2)[n1 + 1], alf(m2)[n1 + 1], slf(m2)[(n1 + 1) + 1]), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 597 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # tl(slf(m2)), ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(m2) = α1 × slf(m2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, sf0(n1 + ii(m2 + 1)) = tl(slf(m2))[n1], sf0 to # sl = sl, tl(slf(m2)) ≠ [], n1 < # tl(slf(m2)), ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(tl(slf(m2))[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # tl(slf(m2)) → sf0((n1 + 1) + ii(m2 + 1)) = tl(slf(m2))[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # alf(m2) → stepf(slf(m2)[n1 + 1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-1, seq: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail), subst:[x, head, tail] → [slf(m2), s, sl0]

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail); (elim) Used terms: slf(m2), head, tail

Proof step 598 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2) = α1 × slf(m2)[0], sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # alf(m2) → stepf(slf(m2)[n1 + 1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ x = a ' + x0 → x[m + 1] = x0[m]; (s) ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ a + x = a ' + x; (s)

Proof step 599 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × hd(slf(m2)), nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s ∈ slf(m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # alf(m2) → stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [slf(m2), s0, sl1]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: slf(m2), s0, y

Proof step 600 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s0, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = s0 + sl1, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # alf(m2) → stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] eq-05: ⊦ x = a ' + y ∧ x = b ' + z → a = b ∧ y = z; (forward) from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ a + x = a ' + x; (s)

Proof step 601 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # alf(m2) → stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule cut formula

And obtained the following new goals

Rule argument

fma: ¬ # alf(m2) ≤ n1 + 1

Additional information

Used formulas: ¬ # alf(m2) ≤ n1 + 1

Proof step 602 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s ∈ slf(m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), ¬ # alf(m2) ≤ n1 + 1, n1 + 1 < # alf(m2) → stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 603 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], n1 + 1 < # alf(m2), ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), s ∈ slf(m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 9, flags: discard

Additional information

Proof step 604 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = (ii0(m2 + 1) + 1) + # sl0, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(n1 + ii0(m2 + 1) + 1) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii0(m2 + 1) + 1 < ii(2 + m2), n1 + 1 < # alf(m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), s ∈ slf(m2), ii0(m2 + 1) + 1 ≤ ii0(2 + m2), n1 + ii0(m2 + 1) + 1 ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii0(m2 + 1) + 1), sf0((n1 + ii0(m2 + 1) + 1) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii0(m2 + 1) + 1) = sl0[n1 + 1], n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m + n - m = n; (s) ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 605 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = # sl0, # alf(m2 + 1) + 1 = # slf(m2 + 1), # sl0 + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, af0((n1 + 1) + ii0(m2 + 1)) = alf(m2)[n1 + 1], ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = (ii0(m2 + 1) + 1) + # sl0, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # sl0, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(2 + n1 + ii0(m2 + 1)) = sl0[n1 + 1], sf0(n1 + ii0(m2 + 1) + 1) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), n1 + 1 < # sl0, n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(m2)[n1 + 1], sl0[n1 + 1]), ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 21, flags: discard

Additional information

Used simplifier rules: ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ a ' + x ≠ []; (s) ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) n ≠ 0 ⊦ (a ' + x)[m + (* n)] = x[m + (n - 1)]; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream]

Proof step 606 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), slf(m2).last = slf(m2 + 1)[0], ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × slf(m2).last, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s ∈ slf(m2), # alf(m2) ≤ n1 + 1, n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # alf(m2) → stepf(sl0[n1], alf(m2)[n1 + 1], slf(m2)[2 + n1]), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m ≤ n → (n < m ↔ false); (s)

Proof step 607 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), slf(m2).last = slf(m2 + 1)[0], ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2).last, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), # alf(m2) ≤ n1 + 1, # alf(m2) ≤ # sl0, ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-last[IOstatestream], name:last-elim, seq:x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a ', subst:[x, a, y] → [slf(m2), s0, sl1]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: slf(m2), s0, y

Proof step 608 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, s0 = slf(m2 + 1)[0], sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s ∈ slf(m2), # alf(m2) ≤ # sl0, # alf(m2) ≤ n1 + 1, n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[IOstatestream]

Proof step 609 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × slf(m2 + 1)[0], nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = sl1 + slf(m2 + 1)[0] ', slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), slf(m2 + 1)[0] ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), # alf(m2) ≤ n1 + 1, # alf(m2) ≤ # sl0, ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:get-zero, seq: ⊦ x ≠ [] → x[0] = hd(x), subst:[x] → [slf(m2 + 1)], <all paths>

Additional information

Used simplifier rules: in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: slf(m2 + 1)

Proof step 610 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x ≠ [] → x[0] = hd(x)

A spec-lemma

Proof step 611 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × hd(slf(m2 + 1)), nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + hd(slf(m2 + 1)) ', sf0 to # sl = sl, sl0 ≠ [], slf(m2 + 1) ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), hd(slf(m2 + 1)) ∈ slf(m2), s ∈ slf(m2), # alf(m2) ≤ # sl0, # alf(m2) ≤ n1 + 1, n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[IOstatestream]

Proof step 612 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) + 1 = # slf(m2 + 1), # alf(m2) + 1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × hd(slf(m2 + 1)), nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = sl1 + hd(slf(m2 + 1)) ', slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2 + 1) ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), hd(slf(m2 + 1)) ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), # alf(m2) ≤ n1 + 1, # alf(m2) ≤ # sl0, ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [slf(m2 + 1), s0, sl2]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: slf(m2 + 1), s0, y

Proof step 613 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) + 1 = # slf(m2), # alf(m2 + 1) + 1 = # slf(m2 + 1), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 1).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 + sl2, sf0 to # sl = sl, sl0 ≠ [], slf(m2 + 1) ≠ [], slf(m2) ≠ [], ii(m2 + 1) < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), # alf(m2) ≤ # sl0, # alf(m2) ≤ n1 + 1, n1 + ii(m2 + 1) ≤ ii0(2 + m2), ii(m2 + 1) ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # alf(m2 + 1) → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], slf(m2 + 1)[n + 1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a ' + x ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ x = a ' + x0 → x[m + 1] = x0[m]; (s) ⊦ a + x = a ' + x; (s)

Proof step 614 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) + 1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = ii0(2 + m2) + 1, ii(2 + m2) = ii(m2 + 1) + # sl0, ii(m2 + 1) = ii0(m2 + 1) + 1, ii(0) = 0, ii(1) = # sl, ii0(0) = 0, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(n1 + ii(m2 + 1)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], n1 < # sl0, ii(m2 + 1) < ii(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ii(m2 + 1) ≤ ii0(2 + m2), n1 + ii(m2 + 1) ≤ ii0(2 + m2), # alf(m2) ≤ n1 + 1, # alf(m2) ≤ # sl0, ¬ stepf(sl0[n1], af0(n1 + ii(m2 + 1)), sf0((n1 + ii(m2 + 1)) + 1)), n1 + 1 < # sl0 → sf0((n1 + 1) + ii(m2 + 1)) = sl0[n1 + 1], n1 + ii(m2 + 1) - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii(m2 + 1) - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii(m2 + 1) - ii0(m2 + 1)], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 8, flags: discard

Additional information

Proof step 615 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) + 1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii(2 + m2) = (ii0(m2 + 1) + 1) + # sl0, ii(2 + m2) = ii0(2 + m2) + 1, ii0(2 + m2) = ii0(m2 + 1) + # alf(m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(n1 + ii0(m2 + 1) + 1) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) + 1 < ii(2 + m2), n1 < # sl0, fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), # alf(m2) ≤ # sl0, # alf(m2) ≤ n1 + 1, n1 + ii0(m2 + 1) + 1 ≤ ii0(2 + m2), ii0(m2 + 1) + 1 ≤ ii0(2 + m2), ¬ stepf(sl0[n1], af0(n1 + ii0(m2 + 1) + 1), sf0((n1 + ii0(m2 + 1) + 1) + 1)), n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1) < # alf(m2) → af0((n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1)) + ii0(m2 + 1)) = alf(m2)[n1 + ii0(m2 + 1) + 1 - ii0(m2 + 1)], n1 + 1 < # sl0 → sf0((n1 + 1) + ii0(m2 + 1) + 1) = sl0[n1 + 1], ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ # x = 0 ↔ x = []; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ¬ m + n < m; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m + 1 ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → n ≠ 0; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m + n - m = n; (s)

Proof step 616 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ (af0 from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = (n = 0 ⊃ al;alf(n - 1)), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 40 terms: 2 + m2 abort: F discard: T computed: F

Additional information

Used terms: 2 + m2

Proof step 617 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii0(0) = 0, ii0((2 + m2) + 1) = ii0(2 + m2) + # (2 + m2 = 0 ⊃ al;alf(2 + m2 - 1)), nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (af0 from ii0(2 + m2)) to # (2 + m2 = 0 ⊃ al;alf(2 + m2 - 1)) = (2 + m2 = 0 ⊃ al;alf(2 + m2 - 1)), alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s)

Proof step 618 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (af0 from ii0(2 + m2)) to # sl2 = alf(1 + m2), sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ (sf0 from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = (n = 0 ⊃ sl;tl(slf(n - 1))), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 43 terms: 2 + m2 abort: F discard: T computed: F

Additional information

Used terms: 2 + m2

Proof step 619 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii((2 + m2) + 1) = ii(2 + m2) + # (2 + m2 = 0 ⊃ sl;tl(slf(2 + m2 - 1))), ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (af0 from ii0(2 + m2)) to # sl2 = alf(1 + m2), (sf0 from ii(2 + m2)) to # (2 + m2 = 0 ⊃ sl;tl(slf(2 + m2 - 1))) = (2 + m2 = 0 ⊃ sl;tl(slf(2 + m2 - 1))), alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ tl(a ' + x) = x; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s)

Proof step 620 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (af0 from ii0(2 + m2)) to # sl2 = alf(1 + m2), (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [alf(1 + m2), (af0 from ii0(2 + m2)) to # sl2], <all paths>

Additional information

Used terms: alf(1 + m2), (af0 from ii0(2 + m2)) to # sl2

Proof step 621 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 622 from proof lemma_2-5-2 (previous step) (back to tree)

#((af0 from ii0(2 + m2)) to # sl2) = # alf(1 + m2), # alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < #((af0 from ii0(2 + m2)) to # sl2) → ((af0 from ii0(2 + m2)) to # sl2)[n] = alf(1 + m2)[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s) c: ⊦ m + n = n + m; from specification nat-basic

Proof step 623 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # sl2 → af0(n + ii0(2 + m2)) = alf(1 + m2)[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 46 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 624 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), 0 < # sl2 → af0(0 + ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 625 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 44 terms: m2 + 2 abort: F discard: T computed: F

Additional information

Used terms: m2 + 2

Proof step 626 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, slf(m2 + 2).last = endstate(nf((m2 + 2) + 1)), slf(m2 + 2)[0] = endstate(nf(m2 + 2)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × (s0 ' + sl2).last, nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 2)⌝ , ⌜alf(m2 + 2)⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 627 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, slf(m2 + 2).last = endstate(nf(3 + m2)), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 2)⌝ , ⌜alf(m2 + 2)⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(3 + m2), α3, s1]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(3 + m2), ασ, st

Proof step 628 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2).last = s1, slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × s1, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(m2 + 2)⌝ , ⌜alf(m2 + 2)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 629 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m2 + 2)⌝ , ⌜alf(m2 + 2)⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(m2 + 2)⌝ , ⌜slf(m2 + 2)⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜alf(m2 + 2)⌝ , ⌜slf(m2 + 2)⌝ , stepf, startf

Proof step 630 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 631 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜slf(m2 + 2)⌝ = # ⌜alf(m2 + 2)⌝ + ⌜1⌝ , # alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. ⌜n⌝ < # ⌜alf(m2 + 2)⌝ → stepf(⌜slf(m2 + 2)⌝ [n], ⌜alf(m2 + 2)⌝ [n], ⌜slf(m2 + 2)⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 632 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), sl2 ≠ [] → af0(ii0(2 + m2)) = alf(1 + m2)[0], ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]) ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 41

Additional information

Proof step 633 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sl2 = [], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ nf to 0 = []; (s)

Proof step 634 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, af((m2 + 1) + m) = τ, alf(m2 + 1) = [], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2), ii0(3 + m2) = ii0(2 + m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × slf(m2 + 2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + slf(m2 + 1), slf(m2 + 1) = slf(m2 + 2)[0] ', sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), slf(m2 + 2)[0] ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 40 terms: (m2 + 1) + m

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: (m2 + 1) + m

Proof step 635 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, (sf0 from ii(2 + m2)) to # sl2 = sl2, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], af0(ii0(2 + m2)), sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 636 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, (sf0 from ii(2 + m2)) to # sl2 = sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[IOstatestream], name:extension, seq: ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n]), subst:[y, x] → [sl2, (sf0 from ii(2 + m2)) to # sl2], <all paths>

Additional information

Used terms: sl2, (sf0 from ii(2 + m2)) to # sl2

Proof step 637 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x[n] = y[n])

A spec-lemma

Proof step 638 from proof lemma_2-5-2 (previous step) (back to tree)

#((sf0 from ii(2 + m2)) to # sl2) = # sl2, # alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < #((sf0 from ii(2 + m2)) to # sl2) → ((sf0 from ii(2 + m2)) to # sl2)[n] = sl2[n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ((nf from n))(m) = nf(m + n); (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ #(nf to n) = n; (s)

Proof step 639 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → sf0(n + ii(2 + m2)) = sl2[n] ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 50 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 640 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), 0 < # sl2 → sf0(0 + ii(2 + m2)) = sl2[0], ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)

Proof step 641 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), sl2 ≠ [] → sf0(ii(2 + m2)) = hd(sl2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]) ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 41

Additional information

Proof step 642 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sl2 = [], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 643 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, af((m2 + 1) + m) = τ, af0(ii0(2 + m2)) = [][0], alf(m2 + 1) = [], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2), ii0(3 + m2) = ii0(2 + m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × slf(m2 + 2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + slf(m2 + 1), slf(m2 + 1) = slf(m2 + 2)[0] ', sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), slf(m2 + 2)[0] ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], [][0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 41 terms: (m2 + 1) + m

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: (m2 + 1) + m

Proof step 644 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sf0(ii(2 + m2)) = hd(sl2), slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 645 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl2, # alf(m2) = n1 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl2, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl2, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii(2 + m2)) = hd(sl2), sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sl2, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], hd(sl2)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]) ⊦

User applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-1, seq: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail), subst:[x, head, tail] → [sl2, s1, sl3]

Additional information

Used simplifier rules: ⊦ x ≠ [] → (head = hd(x) ∧ tail = tl(x) ↔ x = head + tail); (elim) Used terms: sl2, head, tail

Proof step 646 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sf0(ii(2 + m2)) = hd(sl2), sl2 = [], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], hd(sl2)), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 647 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, af((m2 + 1) + m) = τ, af0(ii0(2 + m2)) = [][0], alf(m2 + 1) = [], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2), ii0(3 + m2) = ii0(2 + m2), ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × slf(m2 + 2)[0], nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sf0(ii(2 + m2)) = hd([]), slf(m2) = s ' + sl0, slf(m2) = sl1 + slf(m2 + 1), slf(m2 + 1) = slf(m2 + 2)[0] ', sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), slf(m2 + 2)[0] ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], [][0], hd([])), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 42 terms: (m2 + 1) + m

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: (m2 + 1) + m

Proof step 648 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl2, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (s0 ' + sl2).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl2, ii0(3 + m2) = ii0(2 + m2) + # sl2, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sf0(ii(2 + m2)) = s1, sl2 = s1 + sl3, slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sl2, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], sl2 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], s1), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. n < # sl2 → stepf((s0 ' + sl2)[n], alf(m2 + 1)[n], sl2[n]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s) ⊦ (b ' + a ' + x).last = (a ' + x).last; (s)

Proof step 649 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl3 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (sf0(ii(2 + m2)) ' + sl3).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl3 + 1, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl3 + 1, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sf0(ii(2 + m2)) ' + sl3, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. ¬ # sl3 < n → stepf(slf(m2 + 1)[n], alf(m2 + 1)[n], (sf0(ii(2 + m2)) ' + sl3)[n]) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 49 terms: 0 abort: F discard: T computed: T

Additional information

Used terms: 0

Proof step 650 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl3 + 1, # alf(m2) = n1 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (sf0(ii(2 + m2)) ' + sl3).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl3 + 1, ii0(3 + m2) = ii0(2 + m2) + # sl3 + 1, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sf0(ii(2 + m2)) ' + sl3, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ¬ # sl3 < 0 → stepf(slf(m2 + 1)[0], alf(m2 + 1)[0], (sf0(ii(2 + m2)) ' + sl3)[0]), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ (a ' + x)[0] = a; (s) ⊦ ¬ n < 0; (s)

Proof step 651 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2) = n1 + 1, # alf(m2 + 1) = # sl3 + 1, 2 + n1 = # slf(m2), ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), n1 + 1 = # sl0, # alf(m2 + 2) + 1 = # slf(m2 + 2), slf(m2 + 2)[0] = (sf0(ii(2 + m2)) ' + sl3).last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(3 + m2) = ii(2 + m2) + # sl3 + 1, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(0) = 0, ii(1) = # sl, ii(2 + m2) = ii0(2 + m2) + 1, ii0(0) = 0, ii0(3 + m2) = ii0(2 + m2) + # sl3 + 1, nf(3 + m2) = α3 × slf(m2 + 2).last, nf(0) = ⌜af to m⌝ × sl.last, nf(m2 + 1) = α × s0, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2) = α1 × s, sf0(ii0(2 + m2)) = sl0[n1], slf(m2 + 1) = s0 ' + sf0(ii(2 + m2)) ' + sl3, slf(m2) = sl1 + s0 ', slf(m2) = s ' + sl0, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), startf(sf0(0)), stepf(slf(m2 + 1)[0], alf(m2 + 1)[0], sf0(ii(2 + m2))), s ∈ slf(m2), s0 ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. af(n) ≠ τ, ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: sl1

Additional information

Used simplifier rules: statelist freely generated by [], +;; ⊦ [] + x = x; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ # a ' = 0 +1; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 652 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl3 + 1, # alf(m2) = n1 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), n1 + 1 = # sl0, ii0(m2 + 1) + n1 + 1 = ii0(2 + m2), 2 + n1 = # slf(m2), slf(m2 + 2)[0] = (sf0(ii(2 + m2)) ' + sl3).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + n1, ii(3 + m2) = ii(2 + m2) + # sl3 + 1, ii0(3 + m2) = ii0(2 + m2) + # sl3 + 1, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, sf0(ii0(2 + m2)) = sl0[n1], sl1 = s1 + sl2, slf(m2) = s ' + sl0, slf(m2) = sl1 + s0 ', slf(m2 + 1) = s0 ' + sf0(ii(2 + m2)) ' + sl3, sf0 to # sl = sl, alf(m2) ≠ [], sl0 ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), stepf(slf(m2 + 1)[0], alf(m2 + 1)[0], sf0(ii(2 + m2))), s0 ∈ slf(m2), s ∈ slf(m2), ¬ stepf(sl0[n1], alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ m + n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[IOstatestream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ x + a ' ≠ []; (s) ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s) eq-05: ⊦ x = a ' + y ∧ x = b ' + z → a = b ∧ y = z; (forward) from specification list[IOstatestream] ⊦ a + x = a ' + x; (s)

Proof step 653 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m2 + 1) = # sl3 + 1, # alf(m2) = # sl2 + 1, # alf(m2 + 2) + 1 = # slf(m2 + 2), ii0(m2 + 1) + # sl2 + 1 = ii0(2 + m2), 2 + # sl2 = # slf(m2), slf(m2 + 2)[0] = (sf0(ii(2 + m2)) ' + sl3).last, ⌜alf(m2 + 2)⌝ ^ = ⌜af((m2 + 2) + m) '⌝ ^, ⌜alf(m2)⌝ ^ = ⌜af(m2 + m) '⌝ ^, ⌜alf(m2 + 1)⌝ ^ = ⌜af((m2 + 1) + m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , af0(ii0(2 + m2)) = alf(1 + m2)[0], ii(2 + m2) = ii0(2 + m2) + 1, ii(1) = # sl, ii(0) = 0, ii(2 + m2) = 2 + ii0(m2 + 1) + # sl2, ii(3 + m2) = ii(2 + m2) + # sl3 + 1, ii0(3 + m2) = ii0(2 + m2) + # sl3 + 1, ii0(0) = 0, nf(m2) = α1 × s, nf(2 + m2) = α0 × slf(m2 + 2)[0], nf(m2 + 1) = α × sf0(ii0(2 + m2)), nf(0) = ⌜af to m⌝ × sl.last, nf(3 + m2) = α3 × slf(m2 + 2).last, slf(m2) = s ' + sl2 + sf0(ii0(2 + m2)) ', slf(m2 + 1) = sf0(ii0(2 + m2)) ' + sf0(ii(2 + m2)) ' + sl3, sf0 to # sl = sl, alf(m2) ≠ [], slf(m2) ≠ [], ii0(m2 + 1) < ii0(2 + m2), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sf0(0)), startf(sl[0]), stepf(slf(m2 + 1)[0], alf(m2 + 1)[0], sf0(ii(2 + m2))), sf0(ii0(2 + m2)) ∈ slf(m2), sf0(ii0(2 + m2)) ∈ slf(m2 + 1), s ∈ slf(m2), ¬ stepf(sf0(ii0(2 + m2)), alf(1 + m2)[0], sf0(ii(2 + m2))), ∀ n. n < # alf(m2 + 2) → stepf(slf(m2 + 2)[n], alf(m2 + 2)[n], slf(m2 + 2)[n + 1]), ∀ n. af(n) ≠ τ, ∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 25, flags: discard

Additional information

Used simplifier rules: ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic

Proof step 654 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ⌜af⌝ ≠ α ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, α) ∨ ¬ startf(σ[0]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 655 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ startf(σ[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1 ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 656 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(0 + 1) = ii(0) + # (0 = 0 ⊃ sl;tl(slf(0 - 1))), ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, (σ from ii(0)) to # (0 = 0 ⊃ sl;tl(slf(0 - 1))) = ⌜(0 = 0 ⊃ sl;tl(slf(0 - 1)))⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜ii(0 + 1)⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ σ from 0 = σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 657 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii(1) = # sl, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, σ to # sl = ⌜sl⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 658 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, ii0(0 + 1) = ii0(0) + # (0 = 0 ⊃ al;alf(0 - 1)), nf(0) = ⌜af to m⌝ × sl.last, σ to # sl = ⌜sl⌝ , (α from ii0(0)) to # (0 = 0 ⊃ al;alf(0 - 1)) = ⌜(0 = 0 ⊃ al;alf(0 - 1))⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(0 + 1)⌝ , ¬ # σ < ⌜# sl⌝ , ¬ startf(σ[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ σ from 0 = σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 659 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × sl.last, σ to # sl = ⌜sl⌝ , α to # al = ⌜al⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜# al⌝ , ¬ # σ < ⌜# sl⌝ , ¬ startf(σ[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1 ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 20 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 660 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = endstate(nf(0 + 1)), slf(0)[0] = endstate(nf(0)), ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(0 + m) '⌝ ^, ii(0) = 0, ii(1) = # sl, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, α to # al = ⌜al⌝ , σ to # sl = ⌜sl⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), ¬ # α < ⌜# al⌝ , ¬ # σ < ⌜# sl⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ endstate(ασ × st) = st; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 661 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = endstate(nf(1)), slf(0)[0] = sl.last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # sl, ii0(1) = # al, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, α to # al = ⌜al⌝ , σ to # sl = ⌜sl⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ # α < ⌜# al⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(1), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(1), ασ, st

Proof step 662 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0).last = s, slf(0)[0] = sl.last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × sl.last, nf(1) = α0 × s, σ to # sl = ⌜sl⌝ , α to # al = ⌜al⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ # α < ⌜# al⌝ , ¬ startf(σ[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 663 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0)[0] = sl.last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # sl, ii0(1) = # al, ii0(0) = 0, nf(1) = α0 × slf(0).last, nf(0) = ⌜af to m⌝ × sl.last, α to # al = ⌜al⌝ , σ to # sl = ⌜sl⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ # α < ⌜# al⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[IOstatestream], name:extensionality, seq: ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]), subst:[σ1, σ0] → [⌜sl⌝ , σ to # sl], <all paths>

Additional information

Used terms: ⌜sl⌝ , σ to # sl

Proof step 664 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])

A spec-lemma

Proof step 665 from proof lemma_2-5-2 (previous step) (back to tree)

#(σ to # sl) = # ⌜sl⌝ , slf(0)[0] = sl.last, ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ⌜al⌝ ^ = ⌜af to m⌝ , ii(1) = # sl, ii(0) = 0, ii0(0) = 0, ii0(1) = # al, nf(0) = ⌜af to m⌝ × sl.last, nf(1) = α0 × slf(0).last, α to # al = ⌜al⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ # α < ⌜# al⌝ , ¬ startf(σ[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ n. ⌜n⌝ < #(σ to # sl) → (σ to # sl)[n] = ⌜sl⌝ [n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 666 from proof lemma_2-5-2 (previous step) (back to tree)

slf(0)[0] = sl.last, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜alf(0)⌝ ^ = ⌜af(m) '⌝ ^, ii(0) = 0, ii(1) = # sl, ii0(1) = # al, ii0(0) = 0, nf(1) = α0 × slf(0).last, nf(0) = ⌜af to m⌝ × sl.last, α to # al = ⌜al⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(0)⌝ , ⌜alf(0)⌝ ), startf(sl[0]), ¬ # σ < ⌜# sl⌝ , ¬ # α < ⌜# al⌝ , ¬ startf(σ[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1, ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. n < # sl → σ[n] = sl[n] ⊦

User applied rule all left

And closed the goal!

Rule argument

pos: left 26 terms: 0 abort: F discard: T computed: F

Additional information

Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ frag(IOAut(startf, stepf))([], α); (s) ⊦ x ≠ [] → x[0] = hd(x); (s) Used terms: 0

Proof step 667 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ ⊦ ∀ n. n ≠ 0 → ii(n) = ii0(n) + 1

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 668 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ii(0) = 0, ii0(0) = 0, nf(0) = ⌜af to m⌝ × sl.last, ii(m2) ≠ ii0(m2) + 1, m2 ≠ 0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), (finp(σ) ⊃ # σ = ⌜ii(m0)⌝ ∧ (∀ m. m0 ≤ m → (m = 0 ⊃ sl;tl(slf(m - 1))) = [] ∧ ii(m) = ii(m0));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), (finp(α) ⊃ # α = ⌜ii0(m1)⌝ ∧ (∀ m. m1 ≤ m → (m = 0 ⊃ al;alf(m - 1)) = [] ∧ ii0(m) = ii0(m1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 1, left 4, left 8, left 11, left 12, left 18, left 19, left 20, left 21, left 22

Additional information

Proof step 669 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii(m2) ≠ ii0(m2) + 1, m2 ≠ 0, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ ⊦

User applied rule structural induction

And obtained the following new goals

Rule argument

indvar: m2

Additional information

Used simplifier rules: nat freely generated by 0, +1;;

Proof step 670 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, m0 +1 ≠ 0, ii(m0 +1) ≠ ii0(m0 +1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ ii, ii0, af, startf, stepf, sl, al, slf, alf, nf, m, σ, α. ¬ ( ii(0) = 0 ∧ ii0(0) = 0 ∧ ii(m0) ≠ ii0(m0) + 1 ∧ m0 ≠ 0 ∧ ext(⌜af⌝ ) ∧ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ (∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ ) ∧ (∀ m, n. m ≤ n → ii0(m) ≤ ii0(n)) ∧ (∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ )) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ m +1 = m + 1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s)

Proof step 671 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ ii1, ii2, af0, startf0, stepf0, sl0, al0, slf0, alf0, nf0, m1, σ0, α0. ii1(0) ≠ 0 ∨ ii2(0) ≠ 0 ∨ ii1(m0) = ii2(m0) + 1 ∨ m0 = 0 ∨ ¬ ext(⌜af0⌝ ) ∨ ¬ frag(IOAut(startf0, stepf0))(⌜sl0⌝ , ⌜al0⌝ ) ∨ ¬ startf0(sl0[0]) ∨ ¬ (∀ n0. frag(IOAut(startf0, stepf0))(⌜slf0(n0)⌝ , ⌜alf0(n0)⌝ ) ∧ slf0(n0)[0] = endstate(nf0(n0)) ∧ slf0(n0).last = endstate(nf0(n0 + 1)) ∧ ⌜alf0(n0)⌝ ^ = ⌜af0(n0 + m1) '⌝ ^) ∨ ¬(∀ m, n. m ≤ n → ii1(m) ≤ ii1(n)) ∨ ¬ (∀ n. ii1(n + 1) = ii1(n) + # (n = 0 ⊃ sl0;tl(slf0(n - 1))) ∧ ¬ # σ0 < ⌜ii1(n + 1)⌝ ∧ (σ0 from ii1(n)) to # (n = 0 ⊃ sl0;tl(slf0(n - 1))) = ⌜(n = 0 ⊃ sl0;tl(slf0(n - 1)))⌝ ) ∨ ¬(∀ m, n. m ≤ n → ii2(m) ≤ ii2(n)) ∨ ¬ (∀ n. ii2(n + 1) = ii2(n) + # (n = 0 ⊃ al0;alf0(n - 1)) ∧ ¬ # α0 < ⌜ii2(n + 1)⌝ ∧ (α0 from ii2(n)) to # (n = 0 ⊃ al0;alf0(n - 1)) = ⌜(n = 0 ⊃ al0;alf0(n - 1))⌝ ) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 12 terms: ii, ii0, af, startf, stepf, sl, al, slf, alf, nf, m, σ, α abort: F discard: T computed: T

Additional information

Used terms: ii, ii0, af, startf, stepf, sl, al, slf, alf, nf, m, σ, α

Proof step 672 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ii(0) ≠ 0 ∨ ii0(0) ≠ 0 ∨ ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ∨ ¬ ext(⌜af⌝ ) ∨ ¬ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∨ ¬ startf(sl[0]) ∨ ¬ (∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^) ∨ ¬(∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∨ ¬ (∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ ) ∨ ¬(∀ m, n. m ≤ n → ii0(m) ≤ ii0(n)) ∨ ¬ (∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 673 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii0(0) = 0, ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # (n = 0 ⊃ sl;tl(slf(n - 1))) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ (σ from ii(n)) to # (n = 0 ⊃ sl;tl(slf(n - 1))) = ⌜(n = 0 ⊃ sl;tl(slf(n - 1)))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 9 terms: m0 abort: F discard: T computed: T

Additional information

Used terms: m0

Proof step 674 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii0(0) = 0, (σ from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = ⌜(m0 = 0 ⊃ sl;tl(slf(m0 - 1)))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 675 from proof lemma_2-5-2 (previous step) (back to tree)

ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii(0) = 0, ii0(0) = 0, (σ from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = ⌜(m0 = 0 ⊃ sl;tl(slf(m0 - 1)))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. ii0(n + 1) = ii0(n) + # (n = 0 ⊃ al;alf(n - 1)) ∧ ¬ # α < ⌜ii0(n + 1)⌝ ∧ (α from ii0(n)) to # (n = 0 ⊃ al;alf(n - 1)) = ⌜(n = 0 ⊃ al;alf(n - 1))⌝ , ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 13 terms: m0 abort: F discard: T computed: F

Additional information

Used terms: m0

Proof step 676 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), (σ from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = ⌜(m0 = 0 ⊃ sl;tl(slf(m0 - 1)))⌝ , (α from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = ⌜(m0 = 0 ⊃ al;alf(m0 - 1))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(m0 + 1)⌝ , ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 677 from proof lemma_2-5-2 (previous step) (back to tree)

ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), ii0(0) = 0, (α from ii0(m0)) to # (m0 = 0 ⊃ al;alf(m0 - 1)) = ⌜(m0 = 0 ⊃ al;alf(m0 - 1))⌝ , (σ from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = ⌜(m0 = 0 ⊃ sl;tl(slf(m0 - 1)))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(m0 + 1)⌝ , ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

User applied rule case distinction

And obtained the following new goals

Rule argument

pos: left 5

Additional information

Used simplifier rules: ⊦ n + 0 = n; (s) ⊦ σ from 0 = σ; (s) ⊦ σ from 0 = σ; (s) ⊦ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) → (# sl = # al + 1 ↔ true); (ss) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 678 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii(m0 + 1) = ii(m0) + # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))), ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # (m0 = 0 ⊃ al;alf(m0 - 1)), (σ from ii(m0)) to # (m0 = 0 ⊃ sl;tl(slf(m0 - 1))) = ⌜(m0 = 0 ⊃ sl;tl(slf(m0 - 1)))⌝ , (α from ii0(m0)) to # alf(m0 - 1) = ⌜(m0 = 0 ⊃ al;alf(m0 - 1))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, m0 ≠ 0, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(m0 + 1)⌝ , ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ii(m0) = ii0(m0) + 1 ∨ m0 = 0 ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 679 from proof lemma_2-5-2 (previous step) (back to tree)

ii(0) = 0, ii(m0 + 1) = ii(m0) + # tl(slf(m0 - 1)), ii(m0) = ii0(m0) + 1, ii0(m0 + 1) = ii0(m0) + # alf(m0 - 1), ii0(0) = 0, (α from ii0(m0)) to # alf(m0 - 1) = ⌜alf(m0 - 1)⌝ , (σ from ii(m0)) to # tl(slf(m0 - 1)) = ⌜tl(slf(m0 - 1))⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, m0 ≠ 0, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(m0 + 1)⌝ , ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [m0, m1]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: m0, m1

Proof step 680 from proof lemma_2-5-2 (previous step) (back to tree)

ii(m0) = ii0(m0) + 1, ii(m0 + 1) = ii(m0) + # tl(slf(m1)), ii(0) = 0, ii0(0) = 0, ii0(m0 + 1) = ii0(m0) + # alf(m1), m0 = m1 + 1, (σ from ii(m0)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , (α from ii0(m0)) to # alf(m1) = ⌜alf(m1)⌝ , ii(m0 + 1) ≠ ii0(m0 + 1) + 1, m0 ≠ 0, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(m0 + 1)⌝ , ¬ # σ < ⌜ii(m0 + 1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m + 1 ≠ 0; (s)

Proof step 681 from proof lemma_2-5-2 (previous step) (back to tree)

ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 14 terms: m1 abort: F discard: F computed: F

Additional information

Used terms: m1

Proof step 682 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = endstate(nf(m1 + 1)), slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 683 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = endstate(nf(m1 + 1)), slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1 + 1), α0, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1 + 1), ασ, st

Proof step 684 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1).last = s, slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × s, (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 685 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1)[0] = endstate(nf(m1)), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1 + 1) = α0 × slf(m1).last, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1), α1, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1), ασ, st

Proof step 686 from proof lemma_2-5-2 (previous step) (back to tree)

slf(m1)[0] = s, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × s, (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 687 from proof lemma_2-5-2 (previous step) (back to tree)

⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × slf(m1)[0], nf(m1 + 1) = α0 × slf(m1).last, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜slf(m1)⌝ , ⌜alf(m1)⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:frag, seq:⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])), subst:[β, σ, stepf, startf] → [⌜alf(m1)⌝ , ⌜slf(m1)⌝ , stepf, startf], <all paths>

Additional information

Used terms: ⌜alf(m1)⌝ , ⌜slf(m1)⌝ , stepf, startf

Proof step 688 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))

A spec-lemma

Proof step 689 from proof lemma_2-5-2 (previous step) (back to tree)

# ⌜slf(m1)⌝ = # ⌜alf(m1)⌝ + ⌜1⌝ , ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × slf(m1)[0], (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ n. ⌜n⌝ < # ⌜alf(m1)⌝ → stepf(⌜slf(m1)⌝ [n], ⌜alf(m1)⌝ [n], ⌜slf(m1)⌝ [n +1]) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 690 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m1) + 1 = # slf(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii(2 + m1) = ii(m1 + 1) + # tl(slf(m1)), ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × slf(m1)[0], nf(m1 + 1) = α0 × slf(m1).last, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # tl(slf(m1)) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:length-rest, seq: ⊦ x ≠ [] → # tl(x) = (# x)-1, subst:[x] → [slf(m1)], <all paths>

Additional information

Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: slf(m1)

Proof step 691 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ x ≠ [] → # tl(x) = (# x)-1

A spec-lemma

Proof step 692 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m1) + 1 = # slf(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(2 + m1) = ii(m1 + 1) + (# slf(m1))-1, ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × slf(m1)[0], (σ from ii(m1 + 1)) to (# slf(m1))-1 = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n ≤ m ⊦ (m - n) + n0 = n1 ↔ m + n0 = n + n1; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n -1 = n - 1; (s) ⊦ x ≠ [] → x[0] = hd(x); (s)

Proof step 693 from proof lemma_2-5-2 (previous step) (back to tree)

# alf(m1) + 1 = # slf(m1), # slf(m1) + ii(m1 + 1) = 1 + ii(2 + m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × hd(slf(m1)), nf(m1 + 1) = α0 × slf(m1).last, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to (# slf(m1) - 1) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [# slf(m1), m0]

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # slf(m1), m0

Proof step 694 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = m0 + 1, # slf(m1) + ii(m1 + 1) = 1 + ii(2 + m1), # alf(m1) + 1 = # slf(m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × hd(slf(m1)), (σ from ii(m1 + 1)) to m0 = ⌜tl(slf(m1))⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , # slf(m1) ≠ 0, ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ # x = 0 ↔ x = []; (s)

Proof step 695 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = # alf(m1) + 1, # alf(m1) + ii(m1 + 1) = ii(2 + m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × hd(slf(m1)), nf(m1 + 1) = α0 × slf(m1).last, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # alf(m1) = ⌜tl(slf(m1))⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: list-data[IOstatestream], name:elim-list-c, seq:x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y, subst:[x, a, y] → [slf(m1), s, sl0]

Additional information

Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: slf(m1), s, y

Proof step 696 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = # alf(m1) + 1, # alf(m1) + ii(m1 + 1) = ii(2 + m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × s, slf(m1) = s + sl0, (σ from ii(m1 + 1)) to # alf(m1) = ⌜sl0⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], slf(m1)[n + 1]), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ x = a ' + x0 → x[m + 1] = x0[m]; (s) ⊦ a + x = a ' + x; (s)

Proof step 697 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = # alf(m1) + 1, # alf(m1) + ii(m1 + 1) = ii(2 + m1), ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × s, nf(m1 + 1) = α0 × slf(m1).last, slf(m1) = s ' + sl0, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # alf(m1) = ⌜sl0⌝ , ii(2 + m1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), s ∈ slf(m1), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜ii(2 + m1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], sl0[n]) ⊦

User applied rule subst equation

And obtained the following new goals

Rule argument

pos: left 2, flags: rotate, discard

Additional information

Proof step 698 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = # alf(m1) + 1, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(0) = 0, ii(m1 + 1) = ii0(m1 + 1) + 1, ii0(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), nf(m1 + 1) = α0 × slf(m1).last, nf(m1) = α1 × s, slf(m1) = s ' + sl0, (σ from ii(m1 + 1)) to # alf(m1) = ⌜sl0⌝ , (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , # alf(m1) + ii(m1 + 1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), s ∈ slf(m1), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜# alf(m1) + ii(m1 + 1)⌝ , ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], sl0[n]), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)

Proof step 699 from proof lemma_2-5-2 (previous step) (back to tree)

# slf(m1) = # alf(m1) + 1, ⌜alf(m1)⌝ ^ = ⌜af(m1 + m) '⌝ ^, ii(m1 + 1) = ii0(m1 + 1) + 1, ii(0) = 0, ii0(2 + m1) = ii0(m1 + 1) + # alf(m1), ii0(0) = 0, nf(m1) = α1 × s, nf(m1 + 1) = α0 × slf(m1).last, slf(m1) = s ' + sl0, (α from ii0(m1 + 1)) to # alf(m1) = ⌜alf(m1)⌝ , (σ from ii(m1 + 1)) to # alf(m1) = ⌜sl0⌝ , # alf(m1) + ii(m1 + 1) ≠ ii0(2 + m1) + 1, slf(m1) ≠ [], ext(⌜af⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), s ∈ slf(m1), ¬ # α < ⌜ii0(2 + m1)⌝ , ¬ # σ < ⌜# alf(m1)⌝ + ⌜ii(m1 + 1)⌝ , ∀ n0. frag(IOAut(startf, stepf))(⌜slf(n0)⌝ , ⌜alf(n0)⌝ ) ∧ slf(n0)[0] = endstate(nf(n0)) ∧ slf(n0).last = endstate(nf(n0 + 1)) ∧ ⌜alf(n0)⌝ ^ = ⌜af(n0 + m) '⌝ ^, ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m, n. m ≤ n → ii0(m) ≤ ii0(n), ∀ n. n < # alf(m1) → stepf(slf(m1)[n], alf(m1)[n], sl0[n]) ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 5, flags: discard

Additional information

Used simplifier rules: ⊦ m + n = m + n0 ↔ n = n0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 700 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ n. ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = endstate(nf(n)) ∧ sl0.last = endstate(nf(n + 1)) ∧ ⌜al0⌝ ^ = ⌜af(n + m) '⌝ ^

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 701 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = endstate(nf(m0)) ∧ sl0.last = endstate(nf(m0 + 1)) ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m0), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m0), ασ, st

Proof step 702 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = α × s, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = endstate(nf(m0 + 1)) ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m0 + 1), α0, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m0 + 1), ασ, st

Proof step 703 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0) = α × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α0 × s0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 11 terms: m0 abort: F discard: T computed: F

Additional information

Used terms: m0

Proof step 704 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0 + 1) = α0 × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = α × s, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(m0), nf(m0 + 1)) ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 705 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0) = α × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m0 + 1) = α0 × s0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (α × s, α0 × s0) ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen-basic[Koenigs-Lemma-gen-behact], name:edge-def, seq: ⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b), subst:[b, a, es, vs] → [α0 × s0, α × s, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))], <all paths>

Additional information

Used terms: α0 × s0, α × s, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))

Proof step 706 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b)

A spec-lemma

Proof step 707 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0 + 1) = α0 × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = α × s, after(IOAut(startf, stepf))(actstream(α × s), endstate(α × s)), after(IOAut(startf, stepf))(actstream(α0 × s0), endstate(α0 × s0)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), finp(actstream(α × s)), finp(actstream(α0 × s0)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), actstream(α × s) ≤ ⌜af⌝ , actstream(α0 × s0) ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ a. actstream(α0 × s0) = actstream(α × s) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(α × s), ⌜a '⌝ , endstate(α0 × s0)) ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[actionstream] ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ endstate(ασ × st) = st; (s) ⊦ actstream(ασ × st) = ασ; (s)

Proof step 708 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜al0⌝ × s, nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × s0, after(IOAut(startf, stepf))(⌜al0⌝ , s), after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s, ⌜a '⌝ , s0), startf(sl[0]), ⌜al0⌝ ≤ ⌜af⌝ , ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: IOtrace, name:move, seq:⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β), subst:[stepf, startf, s2, β, s1] → [stepf, startf, s0, ⌜a '⌝ , s], <all paths>

Additional information

Used terms: s0, ⌜a '⌝ , s, stepf, startf

Proof step 709 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)

A spec-lemma

Proof step 710 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × s0, nf(m0) = ⌜al0⌝ × s, nf(0) = ⌜af to m⌝ × sl.last, after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , s0), after(IOAut(startf, stepf))(⌜al0⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜al0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s = sl[0] ∧ s0 = sl.last ∧ α ^ = ⌜a '⌝ ⊦ ∃ sl0, al0. frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ sl0[0] = s ∧ sl0.last = s0 ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 711 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜a '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜al0⌝ × sl0[0], nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × sl0.last, after(IOAut(startf, stepf))(⌜al0⌝ , sl0[0]), after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), startf(sl[0]), ⌜al0⌝ ≤ ⌜af⌝ , ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al0. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ sl[0] = sl0[0] ∧ sl.last = sl0.last ∧ ⌜al0⌝ ^ = ⌜af(m0 + m) '⌝ ^

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: sl0, al1 abort: F discard: T computed: T

Additional information

Used terms: sl0, al1

Proof step 712 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ⌜al1⌝ ^ = ⌜a '⌝ , nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × sl0.last, nf(m0) = ⌜al0⌝ × sl0[0], nf(0) = ⌜af to m⌝ × sl.last, after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last), after(IOAut(startf, stepf))(⌜al0⌝ , sl0[0]), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜al0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ) ∧ sl0[0] = sl0[0] ∧ sl0.last = sl0.last ∧ ⌜al1⌝ ^ = ⌜af(m0 + m) '⌝ ^

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 713 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜a '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜al0⌝ × sl0[0], nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × sl0.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜al0⌝ , sl0[0]), after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), startf(sl[0]), ⌜al0⌝ ≤ ⌜af⌝ , ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: m0 abort: F discard: F computed: F

Additional information

Used terms: m0

Proof step 714 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ⌜al1⌝ ^ = ⌜a '⌝ , actstream(nf(m0)) = ⌜af to m + m0⌝ , nf(m0 + 1) = (⌜al0⌝ + ⌜a '⌝ ) × sl0.last, nf(m0) = ⌜al0⌝ × sl0[0], nf(0) = ⌜af to m⌝ × sl.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜al0⌝ + ⌜a '⌝ , sl0.last), after(IOAut(startf, stepf))(⌜al0⌝ , sl0[0]), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ⌜al0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜al0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ actstream(ασ × st) = ασ; (s)

Proof step 715 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜a '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜af to m + m0⌝ × sl0[0], nf(m0 + 1) = (⌜af to m + m0⌝ + ⌜a '⌝ ) × sl0.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜af to m + m0⌝ , sl0[0]), after(IOAut(startf, stepf))(⌜af to m + m0⌝ + ⌜a '⌝ , sl0.last), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), startf(sl[0]), ⌜af to m + m0⌝ ≤ ⌜af⌝ , ⌜af to m + m0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 16 terms: m0 + 1 abort: F discard: F computed: F

Additional information

Used terms: m0 + 1

Proof step 716 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , ⌜al1⌝ ^ = ⌜a '⌝ , actstream(nf(m0 + 1)) = ⌜af to m + m0 + 1⌝ , nf(m0 + 1) = (⌜af to m + m0⌝ + ⌜a '⌝ ) × sl0.last, nf(m0) = ⌜af to m + m0⌝ × sl0[0], nf(0) = ⌜af to m⌝ × sl.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜af to m + m0⌝ + ⌜a '⌝ , sl0.last), after(IOAut(startf, stepf))(⌜af to m + m0⌝ , sl0[0]), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ⌜af to m + m0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜af to m + m0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[actionstream] append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) ⊦ actstream(ασ × st) = ασ; (s)

Proof step 717 from proof lemma_2-5-2 (previous step) (back to tree)

(af to m + m0) + a ' = af to m + m0 + 1, ⌜al⌝ ^ = ⌜af to m⌝ , ⌜al1⌝ ^ = ⌜a '⌝ , nf(m0 + 1) = (⌜af to m + m0⌝ + ⌜a '⌝ ) × sl0.last, nf(m0) = ⌜af to m + m0⌝ × sl0[0], nf(0) = ⌜af to m⌝ × sl.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜af to m + m0⌝ + ⌜a '⌝ , sl0.last), after(IOAut(startf, stepf))(⌜af to m + m0⌝ , sl0[0]), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), a ∈ af to m + m0 + 1, ⌜af to m + m0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜af to m + m0⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:to-unwind-end-inf, seq: ⊦ nf to m + 1 = (nf to m) + nf(m) ', subst:[m, nf] → [m0 + m, af], <all paths>

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: m0 + m, af

Proof step 718 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ nf to m + 1 = (nf to m) + nf(m) '

A spec-lemma

Proof step 719 from proof lemma_2-5-2 (previous step) (back to tree)

(af to m + m0) + a ' = (af to m0 + m) + af(m0 + m) ', ⌜al1⌝ ^ = ⌜a '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜af to m + m0⌝ × sl0[0], nf(m0 + 1) = (⌜af to m + m0⌝ + ⌜a '⌝ ) × sl0.last, ⌜a '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜af to m + m0⌝ , sl0[0]), after(IOAut(startf, stepf))(⌜af to m + m0⌝ + ⌜a '⌝ , sl0.last), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), startf(sl[0]), a ∈ (af to m0 + m) + af(m0 + m) ', ⌜af to m + m0⌝ ≤ ⌜af⌝ , ⌜af to m + m0⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) c: ⊦ m + n = n + m; from specification nat-basic ⊦ x + a ' = y + b ' ↔ x = y ∧ a = b; (ws)

Proof step 720 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜af(m0 + m) '⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = ⌜af to m + m0⌝ × sl0[0], nf(m0 + 1) = (⌜af to m + m0⌝ + ⌜af(m0 + m) '⌝ ) × sl0.last, ⌜af(m0 + m) '⌝ ≠ ⌜af(m0 + m) '⌝ ^, after(IOAut(startf, stepf))(⌜af to m + m0⌝ , sl0[0]), after(IOAut(startf, stepf))(⌜af to m + m0⌝ + ⌜af(m0 + m) '⌝ , sl0.last), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), startf(sl[0]), ⌜af to m + m0⌝ ≤ ⌜af⌝ , ⌜af to m + m0⌝ + ⌜af(m0 + m) '⌝ ≤ ⌜af⌝ , ∀ n. actstream(nf(n)) = ⌜af to m + n⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: remtau, name:remtau-one, seq: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ , subst:[a] → [af(m0 + m)], <all paths>

Additional information

Used simplifier rules: ⊦ ⌜al⌝ ^ ≠ ⌜τ '⌝ ; (s) Used terms: af(m0 + m)

Proof step 721 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝

A spec-lemma

Proof step 722 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∀ n. actstream(nf(n)) = ⌜af⌝ to m + n

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s)

Proof step 723 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, actstream(nf(m0)) ≠ ⌜af to m + m0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m0), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m0), ασ, st

Proof step 724 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m0) = α × s, α ≠ ⌜af to m + m0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule weakening

And obtained the following new goals

Rule argument

poslist: left 11

Additional information

Proof step 725 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m0) = α × s, nf(0) = ⌜af to m⌝ × sl.last, α ≠ ⌜af to m + m0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

User applied rule structural induction

And obtained the following new goals

Rule argument

indvar: m0

Additional information

Used simplifier rules: nat freely generated by 0, +1;; ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ασ × st = ασ0 × st0 ↔ ασ = ασ0 ∧ st = st0; (ws)

Proof step 726 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m1 +1) = α × s, α ≠ ⌜af to m + m1 +1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ al, af, m, nf, α, s, sl, startf, stepf. ¬ ( ⌜al⌝ ^ = ⌜af to m⌝ ∧ nf(m1) = α × s ∧ nf(0) = ⌜af to m⌝ × sl.last ∧ α ≠ ⌜af to m + m1⌝ ∧ ext(⌜af⌝ ) ∧ fin(IOAut(startf, stepf)) ∧ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ (∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) ∧ (∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1))) ∧ (∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m +1 = m + 1; (s)

Proof step 727 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × s, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ al0, af0, m0, nf0, α0, s0, sl0, startf0, stepf0. ⌜al0⌝ ^ ≠ ⌜af0 to m0⌝ ∨ nf0(m1) ≠ α0 × s0 ∨ nf0(0) ≠ ⌜af0 to m0⌝ × sl0.last ∨ α0 = ⌜af0 to m0 + m1⌝ ∨ ¬ ext(⌜af0⌝ ) ∨ ¬ fin(IOAut(startf0, stepf0)) ∨ ¬ frag(IOAut(startf0, stepf0))(⌜sl0⌝ , ⌜al0⌝ ) ∨ ¬ startf0(sl0[0]) ∨ ¬(∀ α2. finp(α2) ∧ α2 ≤ ⌜af0⌝ → trace(IOAut(startf0, stepf0))(α2)) ∨ ¬ (∀ n. edge ( (λ αs. after(IOAut(startf0, stepf0))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af0⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf0, stepf0))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf0(n), nf0(n + 1))) ∨ ¬(∀ n. after(IOAut(startf0, stepf0))(actstream(nf0(n)), endstate(nf0(n))) ∧ actstream(nf0(n)) ≤ ⌜af0⌝ ∧ finp(actstream(nf0(n)))) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 12 terms: al, af, m, nf, actstream(nf(m1)), endstate(nf(m1)), sl, startf, stepf abort: F discard: T computed: F

Additional information

Used terms: al, af, m, nf, actstream(nf(m1)), endstate(nf(m1)), sl, startf, stepf

Proof step 728 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = α × s, nf(0) = ⌜af to m⌝ × sl.last, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ⌜al⌝ ^ ≠ ⌜af to m⌝ ∨ nf(m1) ≠ actstream(nf(m1)) × endstate(nf(m1)) ∨ nf(0) ≠ ⌜af to m⌝ × sl.last ∨ actstream(nf(m1)) = ⌜af to m + m1⌝ ∨ ¬ ext(⌜af⌝ ) ∨ ¬ fin(IOAut(startf, stepf)) ∨ ¬ frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∨ ¬ startf(sl[0]) ∨ ¬(∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2)) ∨ ¬ (∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1))) ∨ ¬(∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n)))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 729 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × s, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), nf(m1) ≠ actstream(nf(m1)) × endstate(nf(m1)) ∨ actstream(nf(m1)) = ⌜af to m + m1⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(m1), α0, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(m1), ασ, st

Proof step 730 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = α × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = α0 × s0, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), nf(m1) ≠ α0 × s0 ∨ α0 = ⌜af to m + m1⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 731 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = α × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 11 terms: m1 abort: F discard: T computed: F

Additional information

Used terms: m1

Proof step 732 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × s, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(m1), nf(m1 + 1)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 733 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = α × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, α ≠ ⌜af to m + m1 + 1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (⌜af to m + m1⌝ × s0, α × s) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen-basic[Koenigs-Lemma-gen-behact], name:edge-def, seq: ⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b), subst:[b, a, es, vs] → [α × s, ⌜af to m + m1⌝ × s0, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))], <all paths>

Additional information

Used terms: α × s, ⌜af to m + m1⌝ × s0, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))

Proof step 734 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b)

A spec-lemma

Proof step 735 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = α × s, α ≠ ⌜af to m + m1 + 1⌝ , after(IOAut(startf, stepf))(actstream(⌜af to m + m1⌝ × s0), endstate(⌜af to m + m1⌝ × s0)), after(IOAut(startf, stepf))(actstream(α × s), endstate(α × s)), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), finp(actstream(⌜af to m + m1⌝ × s0)), finp(actstream(α × s)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), startf(sl[0]), actstream(⌜af to m + m1⌝ × s0) ≤ ⌜af⌝ , actstream(α × s) ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∃ a. actstream(α × s) = actstream(⌜af to m + m1⌝ × s0) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(⌜af to m + m1⌝ × s0), ⌜a '⌝ , endstate(α × s)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[actionstream] append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ endstate(ασ × st) = st; (s) ⊦ actstream(ασ × st) = ασ; (s) ⊦ finp(⌜nf to n⌝ ); (s)

Proof step 736 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, (af to m + m1) + a ' ≠ af to m + m1 + 1, after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:to-unwind-end-inf, seq: ⊦ nf to m + 1 = (nf to m) + nf(m) ', subst:[m, nf] → [m + m1, af], <all paths>

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: m + m1, af

Proof step 737 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ nf to m + 1 = (nf to m) + nf(m) '

A spec-lemma

Proof step 738 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, (af to m + m1) + a ' ≠ (af to m + m1) + af(m + m1) ', after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ⌜af to m + m1⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ' = b ' ↔ a = b; (s) ⊦ x + y = x + z ↔ y = z; (s)

Proof step 739 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:prefix-def, seq: ⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2), subst:[σ2, σ1] → [⌜af⌝ , ⌜af to m + m1⌝ + ⌜a '⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝ , ⌜af to m + m1⌝ + ⌜a '⌝

Proof step 740 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2)

A spec-lemma

Proof step 741 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∃ α. (⌜af to m + m1⌝ + ⌜a '⌝ ) + α = ⌜af⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 742 from proof lemma_2-5-2 (previous step) (back to tree)

(⌜af to m + m1⌝ + ⌜a '⌝ ) + α = ⌜af⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:extensionality, seq: ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]), subst:[σ1, σ0] → [⌜af⌝ , (⌜af to m + m1⌝ + ⌜a '⌝ ) + α], <all paths>

Additional information

Used terms: ⌜af⌝ , (⌜af to m + m1⌝ + ⌜a '⌝ ) + α

Proof step 743 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])

A spec-lemma

Proof step 744 from proof lemma_2-5-2 (previous step) (back to tree)

#((⌜af to m + m1⌝ + ⌜a '⌝ ) + α) = # ⌜af⌝ , ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. ⌜n⌝ < #((⌜af to m + m1⌝ + ⌜a '⌝ ) + α) → ((⌜af to m + m1⌝ + ⌜a '⌝ ) + α)[n] = ⌜af⌝ [n] ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ ∞ < n∞; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf ⊦ ⌜m⌝ + ∞ = ∞; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ ⌜m⌝ + n∞ = ∞ ↔ n∞ = ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)

Proof step 745 from proof lemma_2-5-2 (previous step) (back to tree)

# α = ∞, ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. ((⌜af to m + m1⌝ + ⌜a '⌝ ) + α)[n] = af(n) ⊦

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 17 terms: m + m1 abort: F discard: T computed: T

Additional information

Used terms: m + m1

Proof step 746 from proof lemma_2-5-2 (previous step) (back to tree)

# α = ∞, ((⌜af to m + m1⌝ + ⌜a '⌝ ) + α)[m + m1] = af(m + m1), ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:get-append-ls, seq: ⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m], subst:[m, σ1, σ] → [m + m1, α, ⌜af to m + m1⌝ + ⌜a '⌝ ], <all paths>

Additional information

Used simplifier rules: ⊦ ¬ ⌜m⌝ < # σ → (σ + σ1)[m] = σ1[m - (# σ).n]; (s) ⊦ ⌜m⌝ + n∞ = ∞ ↔ n∞ = ∞; (s) ⊦ ⌜n⌝ ≠ ∞; (s) n∞ ≠ ∞ ⊦ (⌜m⌝ + n∞).n = m + n∞.n; (s) ⊦ ⌜n⌝ .n = n; (s) ⊦ m + n - n + n1 = m - n1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜n⌝ + n∞1 < ⌜n⌝ + n∞2 ↔ n∞1 < n∞2; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ¬ n < n; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: m + m1, α, ⌜af to m + m1⌝ + ⌜a '⌝

Proof step 747 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m]

A spec-lemma

Proof step 748 from proof lemma_2-5-2 (previous step) (back to tree)

# α = ∞, (⌜af to m + m1⌝ + ⌜a '⌝ )[m + m1] = af(m + m1), ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1) = ⌜af to m + m1⌝ × s0, nf(0) = ⌜af to m⌝ × sl.last, nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, a ≠ af(m + m1), ⌜m + m1⌝ < #(⌜af to m + m1⌝ + ⌜a '⌝ ), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ¬ n < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ⌜n⌝ + n∞1 < ⌜n⌝ + n∞2 ↔ n∞1 < n∞2; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s)

Proof step 749 from proof lemma_2-5-2 (previous step) (back to tree)

# α = ∞, ((af to m + m1) + a ')[m + m1] = af(m + m1), ⌜al⌝ ^ = ⌜af to m⌝ , nf(m1 + 1) = (⌜af to m + m1⌝ + ⌜a '⌝ ) × s, nf(0) = ⌜af to m⌝ × sl.last, nf(m1) = ⌜af to m + m1⌝ × s0, a ≠ af(m + m1), after(IOAut(startf, stepf))(⌜af to m + m1⌝ + ⌜a '⌝ , s), after(IOAut(startf, stepf))(⌜af to m + m1⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), move(IOAut(startf, stepf))(s0, ⌜a '⌝ , s), startf(sl[0]), ⌜af to m + m1⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: list-del[actionstream], name:get-append-grt, seq: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x], subst:[n, y, x] → [m + m1, a ', af to m + m1], <all paths>

Additional information

Used simplifier rules: ⊦ #(nf to n) = n; (s) ⊦ m + n - n + n1 = m - n1; (s) ⊦ m - m = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ a '[0] = a; (s) ⊦ n < # x → (x + a ')[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ n < n; (s) Used terms: m + m1, a ', af to m + m1

Proof step 750 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ ¬ n < # x → (x + y)[n] = y[n - # x]

A spec-lemma

Proof step 751 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al, m. exec(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = ⌜af⌝ to m ∧ actstream(nf(0)) = ⌜al⌝ ^ ∧ endstate(nf(0)) = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)

Proof step 752 from proof lemma_2-5-2 (previous step) (back to tree)

ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ ⌜al⌝ ^ = ⌜af to m⌝ ∧ actstream(nf(0)) = ⌜al⌝ ^ ∧ endstate(nf(0)) = sl.last

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(0), α, s]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(0), ασ, st

Proof step 753 from proof lemma_2-5-2 (previous step) (back to tree)

nf(0) = α × s, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(n), nf(n + 1)), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ ⌜al⌝ ^ = ⌜af to m⌝ ∧ α = ⌜al⌝ ^ ∧ s = sl.last

User applied rule all left

And obtained the following new goals

Rule argument

pos: left 5 terms: 0 abort: F discard: T computed: F

Additional information

Used terms: 0

Proof step 754 from proof lemma_2-5-2 (previous step) (back to tree)

nf(0) = α × s, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (nf(0), nf(0 + 1)) ⊦ ∃ sl, al, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ ⌜al⌝ ^ = ⌜af to m⌝ ∧ α = ⌜al⌝ ^ ∧ s = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 755 from proof lemma_2-5-2 (previous step) (back to tree)

nf(0) = α × s, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), edge ( (λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))) × (λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)))) (α × s, nf(1)) ⊦ ∃ sl, al, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ ⌜al⌝ ^ = ⌜af to m⌝ ∧ α = ⌜al⌝ ^ ∧ s = sl.last

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: infgraph-gen-basic[Koenigs-Lemma-gen-behact], name:edge-def, seq: ⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b), subst:[b, a, es, vs] → [nf(1), α × s, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))], <all paths>

Additional information

Used terms: nf(1), α × s, λ αs1, αs2. ∃ a. actstream(αs2) = actstream(αs1) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(αs1), ⌜a '⌝ , endstate(αs2)), λ αs. after(IOAut(startf, stepf))(actstream(αs), endstate(αs)) ∧ actstream(αs) ≤ ⌜af⌝ ∧ finp(actstream(αs))

Proof step 756 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ edge(vs × es)(a, b) ↔ es(a, b) ∧ vs(a) ∧ vs(b)

A spec-lemma

Proof step 757 from proof lemma_2-5-2 (previous step) (back to tree)

nf(0) = α × s, after(IOAut(startf, stepf))(actstream(α × s), endstate(α × s)), after(IOAut(startf, stepf))(actstream(nf(1)), endstate(nf(1))), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), finp(actstream(α × s)), finp(actstream(nf(1))), actstream(α × s) ≤ ⌜af⌝ , actstream(nf(1)) ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∃ a. actstream(nf(1)) = actstream(α × s) + ⌜a '⌝ ∧ move(IOAut(startf, stepf))(endstate(α × s), ⌜a '⌝ , endstate(nf(1))) ⊦ ∃ sl, al, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ∧ startf(sl[0]) ∧ ⌜al⌝ ^ = ⌜af to m⌝ ∧ α = ⌜al⌝ ^ ∧ s = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[actionstream] ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ endstate(ασ × st) = st; (s) ⊦ actstream(ασ × st) = ασ; (s)

Proof step 758 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + ⌜a '⌝ = actstream(nf(1)), nf(0) = ⌜al⌝ × s, after(IOAut(startf, stepf))(⌜al⌝ , s), after(IOAut(startf, stepf))(actstream(nf(1)), endstate(nf(1))), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), move(IOAut(startf, stepf))(s, ⌜a '⌝ , endstate(nf(1))), ⌜al⌝ ≤ ⌜af⌝ , actstream(nf(1)) ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ s = sl.last

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Rule argument

spec: pair-actionstream-state, name:elim, seq: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st, subst:[αs, ασ, st] → [nf(1), α, s0]

Additional information

Used simplifier rules: ⊦ ασ = actstream(αs) ∧ st = endstate(αs) ↔ αs = ασ × st; (elim) Used terms: nf(1), ασ, st

Proof step 759 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + ⌜a '⌝ = α, nf(0) = ⌜al⌝ × s, nf(1) = α × s0, after(IOAut(startf, stepf))(α, s0), after(IOAut(startf, stepf))(⌜al⌝ , s), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), move(IOAut(startf, stepf))(s, ⌜a '⌝ , s0), α ≤ ⌜af⌝ , ⌜al⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ s = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 760 from proof lemma_2-5-2 (previous step) (back to tree)

nf(1) = (⌜al⌝ + ⌜a '⌝ ) × s0, nf(0) = ⌜al⌝ × s, after(IOAut(startf, stepf))(⌜al⌝ , s), after(IOAut(startf, stepf))(⌜al⌝ + ⌜a '⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), move(IOAut(startf, stepf))(s, ⌜a '⌝ , s0), ⌜al⌝ ≤ ⌜af⌝ , ⌜al⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ s = sl.last

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [s, ⌜al⌝ , stepf, startf], <all paths>

Additional information

Used terms: s, ⌜al⌝ , stepf, startf

Proof step 761 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 762 from proof lemma_2-5-2 (previous step) (back to tree)

nf(0) = ⌜al⌝ × s, nf(1) = (⌜al⌝ + ⌜a '⌝ ) × s0, after(IOAut(startf, stepf))(⌜al⌝ + ⌜a '⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), move(IOAut(startf, stepf))(s, ⌜a '⌝ , s0), ⌜al⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜al⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ α, σ. α ^ = ⌜al⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ s = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 763 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , nf(1) = (⌜al⌝ + ⌜a '⌝ ) × s0, nf(0) = ⌜al⌝ × σ.l.last, after(IOAut(startf, stepf))(⌜al⌝ + ⌜a '⌝ , s0), ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , s0), startf(σ[0]), ⌜al⌝ ≤ ⌜af⌝ , ⌜al⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: restricted, name:after, seq:⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last), subst:[s, β, stepf, startf] → [s0, ⌜al⌝ + ⌜a '⌝ , stepf, startf], <all paths>

Additional information

Used terms: s0, ⌜al⌝ + ⌜a '⌝ , stepf, startf

Proof step 764 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ after(IOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)

A spec-lemma

Proof step 765 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , nf(0) = ⌜al⌝ × σ.l.last, nf(1) = (⌜al⌝ + ⌜a '⌝ ) × s0, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , s0), startf(σ[0]), ⌜al⌝ + ⌜a '⌝ ≤ ⌜af⌝ , ⌜al⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ α, σ. α ^ = ⌜al⌝ + ⌜a '⌝ ∧ exec*(IOAut(startf, stepf))(σ, α) ∧ s0 = σ.l.last ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ exec(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ exec*(IOAut(startf, stepf))(σ, β) ↔ exec(IOAut(startf, stepf))(σ, β) ∧ finp(β); (s)

Proof step 766 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(1) = ⌜al1⌝ ^ × σ0.l.last, nf(0) = ⌜al⌝ × σ.l.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), frag(IOAut(startf, stepf))(σ0, ⌜al1⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , σ0.l.last), startf(σ[0]), startf(σ0[0]), ⌜al⌝ ≤ ⌜af⌝ , ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ0

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)

Proof step 767 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × σ.l.last, nf(1) = ⌜al1⌝ ^ × σ0.l.last, σ0 = ⌜sl0⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ0, ⌜al1⌝ ), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , σ0.l.last), startf(σ0[0]), startf(σ[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ⌜al⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 768 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(0) = ⌜al⌝ × σ.l.last, nf(1) = ⌜al1⌝ ^ × sl0.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , sl0.last), startf(σ[0]), startf(sl0[0]), ⌜al⌝ ≤ ⌜af⌝ , ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: σ

Additional information

Used simplifier rules: statestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ frag(IOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)

Proof step 769 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(1) = ⌜al1⌝ ^ × sl0.last, nf(0) = ⌜al⌝ × σ.l.last, σ = ⌜sl1⌝ , ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(σ, ⌜al0⌝ ), move(IOAut(startf, stepf))(σ.l.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(σ[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ⌜al⌝ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ ∃ sl, al0, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al0⌝ ) ∧ startf(sl[0]) ∧ ⌜al0⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ σ.l.last = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)

Proof step 770 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(1) = ⌜al1⌝ ^ × sl0.last, nf(0) = ⌜al⌝ × sl1.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl1[0]), startf(sl0[0]), ⌜al⌝ ≤ ⌜af⌝ , ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al2, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al2⌝ ) ∧ startf(sl[0]) ∧ ⌜al2⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al2⌝ ^ ∧ sl1.last = sl.last

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:prefix-def, seq: ⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2), subst:[σ2, σ1] → [⌜af⌝ , ⌜al⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝ , ⌜al⌝

Proof step 771 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ1 ≤ σ2 ↔ (∃ σ. σ1 + σ = σ2)

A spec-lemma

Proof step 772 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × sl1.last, nf(1) = ⌜al1⌝ ^ × sl0.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(sl1[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∃ α. ⌜al⌝ + α = ⌜af⌝ ⊦ ∃ sl, al2, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al2⌝ ) ∧ startf(sl[0]) ∧ ⌜al2⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al2⌝ ^ ∧ sl1.last = sl.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 773 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + α = ⌜af⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(1) = ⌜al1⌝ ^ × sl0.last, nf(0) = ⌜al⌝ × sl1.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl1[0]), startf(sl0[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦ ∃ sl, al2, m. frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al2⌝ ) ∧ startf(sl[0]) ∧ ⌜al2⌝ ^ = ⌜af to m⌝ ∧ ⌜al⌝ = ⌜al2⌝ ^ ∧ sl1.last = sl.last

User applied rule exists right

And obtained the following new goals

Rule argument

pos: right 1 terms: sl1, al0, (# ⌜al0⌝ ^).n abort: F discard: T computed: F

Additional information

Used terms: sl1, al0, (# ⌜al0⌝ ^).n

Proof step 774 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + α = ⌜af⌝ , ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × sl1.last, nf(1) = ⌜al1⌝ ^ × sl0.last, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(sl1[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ startf(sl1[0]) ∧ ⌜al0⌝ ^ = ⌜af to (# ⌜al0⌝ ^).n⌝ ∧ ⌜al⌝ = ⌜al0⌝ ^ ∧ sl1.last = sl1.last

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜n⌝ .n = n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)

Proof step 775 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + α = ⌜af⌝ , ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × sl1.last, nf(1) = ⌜al1⌝ ^ × sl0.last, al ≠ af to # al, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(sl1[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule constructor cut

And obtained the following new goals

Rule argument

var: α

Additional information

Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ σ0 + ⌜x⌝ = ⌜nf0⌝ ↔ σ0 = ⌜nf0⌝ ; (s) ⊦ ⌜x⌝ ≠ ⌜nf⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]

Proof step 776 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + α = ⌜af⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(1) = ⌜al1⌝ ^ × sl0.last, nf(0) = ⌜al⌝ × sl1.last, α = ⌜af0⌝ , al ≠ af to # al, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl1[0]), startf(sl0[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Proof step 777 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al⌝ + ⌜af0⌝ = ⌜af⌝ , ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × sl1.last, nf(1) = ⌜al1⌝ ^ × sl0.last, al ≠ af to # al, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(sl1[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Rule argument

spec: stream[actionstream], name:extensionality-to, seq: ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ¬ # σ0 < ⌜n⌝ → σ0 to n = σ1 to n), subst:[σ1, σ0] → [⌜af⌝ , ⌜al⌝ + ⌜af0⌝ ], <all paths>

Additional information

Used terms: ⌜af⌝ , ⌜al⌝ + ⌜af0⌝

Proof step 778 from proof lemma_2-5-2 (previous step) (back to tree)

⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ¬ # σ0 < ⌜n⌝ → σ0 to n = σ1 to n)

A spec-lemma

Proof step 779 from proof lemma_2-5-2 (previous step) (back to tree)

#(⌜al⌝ + ⌜af0⌝ ) = # ⌜af⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , ⌜al0⌝ ^ = ⌜al⌝ , nf(1) = ⌜al1⌝ ^ × sl0.last, nf(0) = ⌜al⌝ × sl1.last, al ≠ af to # al, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl1[0]), startf(sl0[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ n. ¬ #(⌜al⌝ + ⌜af0⌝ ) < ⌜n⌝ → ⌜al⌝ + ⌜af0⌝ to n = ⌜af⌝ to n ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ + ∞ = ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 780 from proof lemma_2-5-2 (previous step) (back to tree)

⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ + ⌜a '⌝ , nf(0) = ⌜al⌝ × sl1.last, nf(1) = ⌜al1⌝ ^ × sl0.last, al ≠ af to # al, ext(⌜af⌝ ), fin(IOAut(startf, stepf)), frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), move(IOAut(startf, stepf))(sl1.last, ⌜a '⌝ , sl0.last), startf(sl0[0]), startf(sl1[0]), ⌜al1⌝ ^ ≤ ⌜af⌝ , ∀ n. after(IOAut(startf, stepf))(actstream(nf(n)), endstate(nf(n))) ∧ actstream(nf(n)) ≤ ⌜af⌝ ∧ finp(actstream(nf(n))), ∀ σ, β. ⌜af⌝ ≠ β ^ ∨ ¬ frag(IOAut(startf, stepf))(σ, β) ∨ ¬ startf(σ[0]), ∀ α2. finp(α2) ∧ α2 ≤ ⌜af⌝ → trace(IOAut(startf, stepf))(α2), ∀ n. ⌜al⌝ + ⌜af0⌝ to n = ⌜af to n⌝ ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 17 terms: # al

Additional information

Used simplifier rules: ⊦ ⌜x⌝ + σ to # x = ⌜x⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) Used terms: # al

Proof Tree for lemma_2-5-2 (View conclusion)

The following image shows the proof tree of sequent calculus. The proved goal is at the bottom. You can click on the nodes to view additional rules. See here for details on colors in a proof tree.

the proof tree