| bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) |
bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦
| bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ |
⊦ bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ))
¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦
Used terms: r, astepf, astartf, cstepf, cstartf
| ⊦ bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) )) |
| ¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ |
¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
| ¬ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))
∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), (∃ cs. ¬(cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)))) ∨ (∃ cs, a, cs0, as. ¬(r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))) ⊦
Used terms: r, astepf, astartf, cstepf, cstartf
| ⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0))) |
| ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), (∃ cs. ¬(cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)))) ∨ (∃ cs, a, cs0, as. ¬(r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))) ⊦ |
∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬(cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∨ ¬(r(as, cs0) ∧ cstepf(cs0, a, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1))) ⊦
| ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬(cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∨ ¬(r(as, cs0) ∧ cstepf(cs0, a, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1))) ⊦ |
cstartf(cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ ∃ as. r(as, cs) ∧ astartf(as)
cstepf(cs0, a, cs1), r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1)
| cstartf(cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ ∃ as. r(as, cs) ∧ astartf(as) |
Used terms: cs
| cstepf(cs0, a, cs1), r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1) |
cstepf(cs0, a, cs1), r(as, cs0), r(as, cs0) ∧ cstepf(cs0, a, cs1) → (a = τ ⊃ r(as, cs1) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs0)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs1) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1)
Used terms: cs0, a, cs1, as
| cstepf(cs0, a, cs1), r(as, cs0), r(as, cs0) ∧ cstepf(cs0, a, cs1) → (a = τ ⊃ r(as, cs1) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs0)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs1) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1) |
cstepf(cs0, a, cs1), r(as, cs0), (a = τ ⊃ r(as, cs1) ;afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs0)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs1) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1)
| cstepf(cs0, a, cs1), r(as, cs0), (a = τ ⊃ r(as, cs1) ;afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs0)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs1) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1) |
a = τ, cstepf(cs0, a, cs1), r(as, cs0), r(as, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1)
⌜al⌝ ^ = [], hd(asl) = as, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1)
| a = τ, cstepf(cs0, a, cs1), r(as, cs0), r(as, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1) |
cstepf(cs0, τ, cs1), r(as, cs1), r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ r(as0, cs1)
Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)
| cstepf(cs0, τ, cs1), r(as, cs1), r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ r(as0, cs1) |
Used simplifier rules: ⊦ amove(AIOAut(startf, stepf))(s, [], s); (s) Used terms: as
| ⌜al⌝ ^ = [], hd(asl) = as, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(hd(asl), cs0), ∀ as. as ∈ asl → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(hd(asl), ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used simplifier rules: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(hd(asl), cs0), ∀ as. as ∈ asl → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(hd(asl), ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], asl = as2 + asl0, a ≠ τ, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl, as2, y
| ⌜al⌝ ^ = [], asl = as2 + asl0, a ≠ τ, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], asl0 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used formulas: asl0 = []
| ⌜al⌝ ^ = [], asl0 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used simplifier rules: ⊦ ¬ a ∈ []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ σ + [] = σ; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ x + [] = x; (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1) ∧ r(as1, cs1)
Used terms: as1
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1) ∧ r(as1, cs1) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as2 = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦
Used terms: as1, ⌜a '⌝ , as2, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as2 = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦ |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ , ⌜al⌝ ), astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜as2 '⌝ = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = [], a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ , ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n. ⌜n⌝ < # ⌜al⌝ → astepf(⌜as2 '⌝ [n], ⌜al⌝ [n], ⌜as2 '⌝ [n +1]) ⊦
Used terms: ⌜al⌝ , ⌜as2 '⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜as2 '⌝ = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = [], a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ , ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n. ⌜n⌝ < # ⌜al⌝ → astepf(⌜as2 '⌝ [n], ⌜al⌝ [n], ⌜as2 '⌝ [n +1]) ⊦ |
a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ , ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ⌜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 ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ m ≤ n → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ = n∞2); (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ , ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 ' + as1 '⌝ , ⌜a '⌝ ) ∨ ¬ finp(⌜a '⌝ ) ∨ as2 ≠ (as2 ' + as1 ')[0] ∨ as1 ≠ (as2 ' + as1 ').last ∨ ⌜a '⌝ ^ ≠ ⌜a '⌝ ⊦
Used terms: ⌜a '⌝ , as2 ' + as1 '
| a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 ' + as1 '⌝ , ⌜a '⌝ ) ∨ ¬ finp(⌜a '⌝ ) ∨ as2 ≠ (as2 ' + as1 ')[0] ∨ as1 ≠ (as2 ' + as1 ').last ∨ ⌜a '⌝ ^ ≠ ⌜a '⌝ ⊦ |
a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜as1 '⌝ , ⌜a '⌝ ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| a ≠ τ, astepf(as2, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜as1 '⌝ , ⌜a '⌝ ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
Used simplifier rules: ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic 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 ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ (⌜a '⌝ + σ)[0] = a; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) n ≠ 0 ⊦ (⌜a '⌝ + σ)[(* n)] = σ[n - 1]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] Used terms: ⌜a '⌝ , ⌜as2 '⌝ + ⌜as1 '⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf((as2 ' + asl0).last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s)
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as0) ∧ r(as0, cs1) |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1) ∧ r(as1, cs1)
Used terms: as1
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1) ∧ r(as1, cs1) |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ amove(AIOAut(astartf, astepf))(as2, ⌜a '⌝ , as1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as2 = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦
Used terms: as1, ⌜a '⌝ , as2, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as2 = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦ |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as2 ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 + (asl0 + as1 ')⌝ , ⌜al + a '⌝ ) ∨ ¬ finp(⌜al + a '⌝ ) ∨ as2 ≠ (as2 + (asl0 + as1 '))[0] ∨ as1 ≠ (as2 + (asl0 + as1 ')).last ∨ ⌜al + a '⌝ ^ ≠ ⌜a '⌝ ⊦
Used terms: ⌜al + a '⌝ , as2 + (asl0 + as1 ')
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 + (asl0 + as1 ')⌝ , ⌜al + a '⌝ ) ∨ ¬ finp(⌜al + a '⌝ ) ∨ as2 ≠ (as2 + (asl0 + as1 '))[0] ∨ as1 ≠ (as2 + (asl0 + as1 ')).last ∨ ⌜al + a '⌝ ^ ≠ ⌜a '⌝ ⊦ |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ , ⌜al⌝ + ⌜a '⌝ ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] finp(σ) ⊦ σ0 + σ = σ ↔ σ0 = []; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ y ≠ [] → (x + y + z).last = (y + z).last; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ , ⌜al⌝ + ⌜a '⌝ ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), #(⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → astepf((⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], (⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ )[n +1]))) ⊦
Used terms: ⌜al⌝ + ⌜a '⌝ , ⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), #(⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → astepf((⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], (⌜as2 '⌝ + ⌜asl0⌝ + ⌜as1 '⌝ )[n +1]))) ⊦ |
⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), # asl0 ≠ # al ∨ ¬(¬ # al < n → astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n])) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] 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) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (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) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al⌝ ), astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), # asl0 ≠ # al ∨ ¬(¬ # al < n → astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n])) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
#(⌜as2 '⌝ + ⌜asl0⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n. ⌜n⌝ < # ⌜al⌝ → astepf((⌜as2 '⌝ + ⌜asl0⌝ )[n], ⌜al⌝ [n], (⌜as2 '⌝ + ⌜asl0⌝ )[n +1]), # asl0 ≠ # al ∨ ¬(¬ # al < n → astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n])) ⊦
Used terms: ⌜al⌝ , ⌜as2 '⌝ + ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| #(⌜as2 '⌝ + ⌜asl0⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n. ⌜n⌝ < # ⌜al⌝ → astepf((⌜as2 '⌝ + ⌜asl0⌝ )[n], ⌜al⌝ [n], (⌜as2 '⌝ + ⌜asl0⌝ )[n +1]), # asl0 ≠ # al ∨ ¬(¬ # al < n → astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n])) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-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) ⊦ m < n ↔ ¬ n ≤ m; (ss) 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)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ n < # as2 ', ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n < # as2 ', astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ astepf(as2 '[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used terms: n, asl0 + as1 ', as2 '
| ⊦ n < # x → (x + y)[n] = x[n] |
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ n < # as2 ', ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((as2 ' + asl0 + as1 ')[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ n < # as2 ', ¬ astepf((asl0 + as1 ')[n - # as2 '], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) Used terms: as2 ', asl0 + as1 ', n
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ n < # as2 ', ¬ astepf((asl0 + as1 ')[n - # as2 '], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((asl0 + as1 ')[n - 1], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), n ≤ # al, ¬ astepf((asl0 + as1 ')[n - 1], (al + a ')[n], (asl0 + as1 ')[n]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], n = n1 + 1, a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ astepf((asl0 + as1 ')[n1], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, m
| # asl0 = # al, ⌜al⌝ ^ = [], n = n1 + 1, a ≠ τ, asl0 ≠ [], n ≠ 0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ astepf((asl0 + as1 ')[n1], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(asl0[n1], (al + a ')[n1 + 1], (asl0 + as1 ')[n1 + 1]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) ⊦ # 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 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)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(asl0[n1], (al + a ')[n1 + 1], (asl0 + as1 ')[n1 + 1]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 + 1 < # al, n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(asl0[n1], (al + a ')[n1 + 1], (asl0 + as1 ')[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ n1 + 1 < # al, ¬ astepf(asl0[n1], a '[n1 + 1 - # al], (asl0 + as1 ')[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used terms: al, a ', n1 + 1
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 + 1 < # al, n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(asl0[n1], (al + a ')[n1 + 1], (asl0 + as1 ')[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 + 1 < # al, n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(asl0[n1], al[n1 + 1], asl0[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ n < # x → (x + a ')[n] = x[n]; (s)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 + 1 < # al, n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(asl0[n1], al[n1 + 1], asl0[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
Used simplifier rules: ⊦ (a ' + x)[n + 1] = x[n]; (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[traceA-IOstatestream] Used terms: n1 + 1
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], n1 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ n1 + 1 < # al, ¬ astepf(asl0[n1], a '[n1 + 1 - # al], (asl0 + as1 ')[n1 + 1]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
# asl0 = n1 + 1, # al = n1 + 1, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(asl0[n1], a, as1), ∀ n0. ¬ n1 < n0 → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
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) le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ a '[0] = a; (s) ⊦ m - m = 0; (s) ⊦ m + n - n + n1 = m - n1; (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 ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # asl0 = n1 + 1, # al = n1 + 1, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(asl0[n1], a, as1), ∀ n0. ¬ n1 < n0 → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
Used simplifier rules: ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) ⊦ 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 ⊦ x + a ' ≠ []; (s) ⊦ n = # x → (x + a ')[n] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: asl0, as0, y
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], n < # as2 ', astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), n ≤ # al, ¬ astepf(as2 '[n], (al + a ')[n], (asl0 + as1 ')[n]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, (al + a ')[0], (asl0 + as1 ')[0]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: ⊦ a '[0] = a; (s) ⊦ 0 ≤ m; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, (al + a ')[0], (asl0 + as1 ')[0]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], 0 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, al[0], (asl0 + as1 ')[0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) Used terms: 0, a ', al
| ⊦ n < # x → (x + y)[n] = x[n] |
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, asl0 ≠ [], 0 < # al, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, al[0], (asl0 + as1 ')[0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, hd(al), (asl0 + as1 ')[0]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # asl0 = # al, ⌜al⌝ ^ = [], a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, hd(al), (asl0 + as1 ')[0]), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ |
# asl0 = # al, ⌜al⌝ ^ = [], al = a0 + al0, a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, a0, (asl0 + as1 ')[0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: al, a0, y
| # asl0 = # al, ⌜al⌝ ^ = [], al = a0 + al0, a ≠ τ, al ≠ [], asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, a0, (asl0 + as1 ')[0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0), ∀ n0. n0 < # al → astepf((as2 ' + asl0)[n0], al[n0], asl0[n0]) ⊦ |
# asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, (asl0 + as1 ')[0]), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦
Used simplifier rules: ⊦ a + x = 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 + 1 ↔ ¬ n < m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, (asl0 + as1 ')[0]), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], 0 < # asl0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, τ, asl0[0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]) ⊦
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) Used terms: 0, as1 ', asl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| # asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], 0 < # asl0, astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, τ, asl0[0]), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]) ⊦ |
# asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, hd(asl0)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # asl0 = # al0 + 1, ⌜al0⌝ ^ = [], a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, hd(asl0)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs0) ⊦ |
# asl0 = # al0 + 1, ⌜al0⌝ ^ = [], asl0 = as0 + asl, a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, τ, as0), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as0, y
| # asl0 = # al0 + 1, ⌜al0⌝ ^ = [], asl0 = as0 + asl, a ≠ τ, asl0 ≠ [], astepf(asl0.last, a, as1), cstepf(cs0, a, cs1), r(as2, cs0), r(as1, cs1), ¬ astepf(as2, τ, as0), ∀ as. as ∈ asl0 → r(as, cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + asl0)[n0], (τ ' + al0)[n0], asl0[n0]) ⊦ |
# asl = # al0, ⌜al0⌝ ^ = [], a ≠ τ, astepf((as0 ' + asl).last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, as0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + as0 ' + asl)[n0], (τ ' + al0)[n0], (as0 ' + asl)[n0]), ∀ as. as = as0 ∨ as ∈ asl → r(as, cs0) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a + x = 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)
| # asl = # al0, ⌜al0⌝ ^ = [], a ≠ τ, astepf((as0 ' + asl).last, a, as1), cstepf(cs0, a, cs1), r(as1, cs1), r(as2, cs0), ¬ astepf(as2, τ, as0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ n0. ¬ # al0 < n0 → astepf((as2 ' + as0 ' + asl)[n0], (τ ' + al0)[n0], (as0 ' + asl)[n0]), ∀ as. as = as0 ∨ as ∈ asl → r(as, cs0) ⊦ |
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: 0
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.