| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (hist(CIOAut(cstartf, cstepf)), AIOAut(astartf, astepf), λ αcs, as. ∃ aσ, α. aexec*(AIOAut(astartf, astepf))(aσ, α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(as)), λ αcs. ∃ cσ, α. cexec*(CIOAut(cstartf, cstepf))(cσ, α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ as. true) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (hist(CIOAut(cstartf, cstepf)), AIOAut(astartf, astepf), λ αcs, as. ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(aσ.l.last)), λ αcs. ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ as. true)
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (hist(CIOAut(cstartf, cstepf)), AIOAut(astartf, astepf), λ αcs, as. ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(aσ.l.last)), λ αcs. ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ as. true) |
⊦ hist(CIOAut(startf, stepf)) = CHIOAut (λ αs. cactstream(αs) = [] ∧ startf(cendstate(αs)), λ αs, a, αs0. finp(cactstream(αs)) ∧ cmove(CIOAut(startf, stepf))(cendstate(αs), ⌜a '⌝ ^, cendstate(αs0)) ∧ cactstream(αs0) = cactstream(αs) + ⌜a '⌝ ^)
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (CHIOAut (λ αs. cactstream(αs) = [] ∧ cstartf(cendstate(αs)), λ αs, a, αs0. finp(cactstream(αs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(αs), ⌜a '⌝ ^, cendstate(αs0)) ∧ cactstream(αs0) = cactstream(αs) + ⌜a '⌝ ^), AIOAut(astartf, astepf), λ αcs, as. ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(aσ.l.last)), λ αcs. ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ as. true)
Used terms: cstepf, cstartf
| ⊦ hist(CIOAut(startf, stepf)) = CHIOAut (λ αs. cactstream(αs) = [] ∧ startf(cendstate(αs)), λ αs, a, αs0. finp(cactstream(αs)) ∧ cmove(CIOAut(startf, stepf))(cendstate(αs), ⌜a '⌝ ^, cendstate(αs0)) ∧ cactstream(αs0) = cactstream(αs) + ⌜a '⌝ ^) |
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (CHIOAut (λ αs. cactstream(αs) = [] ∧ cstartf(cendstate(αs)), λ αs, a, αs0. finp(cactstream(αs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(αs), ⌜a '⌝ ^, cendstate(αs0)) ∧ cactstream(αs0) = cactstream(αs) + ⌜a '⌝ ^), AIOAut(astartf, astepf), λ αcs, as. ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(aσ.l.last)), λ αcs. ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ as. true) |
⊦ bwsim(CHIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)))
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (∀ _cs. cactstream(_cs) = [] ∧ cstartf(cendstate(_cs)) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^)) ∧ (∀ as. astartf(as) → true) ∧ (∀ _cs, a, _cs0. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) ∧ finp(cactstream(_cs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs), ⌜a '⌝ ^, cendstate(_cs0)) ∧ cactstream(_cs0) = cactstream(_cs) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^)) ∧ (∀ as, a, as0. true ∧ astepf(as, a, as0) → true) ∧ (∀ _cs. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) → (∃ as. (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last))) ∧ true)) ∧ (∀ _cs, as. (cactstream(_cs) = [] ∧ cstartf(cendstate(_cs))) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last))) ∧ true → astartf(as)) ∧ (∀ _cs, a, _cs0, as0. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) ∧ ( finp(cactstream(_cs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs), ⌜a '⌝ ^, cendstate(_cs0)) ∧ cactstream(_cs0) = cactstream(_cs) + ⌜a '⌝ ^) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as0 ∧ α ^ = cactstream(_cs0) ∧ (cactstream(_cs0) = [] → astartf(aσ.l.last))) ∧ true → (∃ as. true ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last)))))
Used terms: λ as. true, λ αcs. ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(αcs) ∧ cactstream(αcs) = α ^, λ αcs, as. ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(αcs) ∧ (cactstream(αcs) = [] → astartf(aσ.l.last)), astepf, astartf, λ αcs, a, αcs0. finp(cactstream(αcs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(αcs), ⌜a '⌝ ^, cendstate(αcs0)) ∧ cactstream(αcs0) = cactstream(αcs) + ⌜a '⌝ ^, λ αcs. cactstream(αcs) = [] ∧ cstartf(cendstate(αcs))
| ⊦ bwsim(CHIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))) |
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (∀ _cs. cactstream(_cs) = [] ∧ cstartf(cendstate(_cs)) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^)) ∧ (∀ as. astartf(as) → true) ∧ (∀ _cs, a, _cs0. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) ∧ finp(cactstream(_cs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs), ⌜a '⌝ ^, cendstate(_cs0)) ∧ cactstream(_cs0) = cactstream(_cs) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^)) ∧ (∀ as, a, as0. true ∧ astepf(as, a, as0) → true) ∧ (∀ _cs. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) → (∃ as. (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last))) ∧ true)) ∧ (∀ _cs, as. (cactstream(_cs) = [] ∧ cstartf(cendstate(_cs))) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last))) ∧ true → astartf(as)) ∧ (∀ _cs, a, _cs0, as0. (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^) ∧ ( finp(cactstream(_cs)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs), ⌜a '⌝ ^, cendstate(_cs0)) ∧ cactstream(_cs0) = cactstream(_cs) + ⌜a '⌝ ^) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as0 ∧ α ^ = cactstream(_cs0) ∧ (cactstream(_cs0) = [] → astartf(aσ.l.last))) ∧ true → (∃ as. true ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs) ∧ (cactstream(_cs) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ ( cactstream(_cs) = [] ∧ cstartf(cendstate(_cs)) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ ( cactstream(_cs) = [] ∧ cstartf(cendstate(_cs)) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs) ∧ cactstream(_cs) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs = α3 × cs, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ α3 = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs, α3, cs
| _cs = α3 × cs, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ α3 = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs0) ∧ cactstream(_cs0) = α ^ ∧ finp(cactstream(_cs0)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs0), ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = cactstream(_cs0) + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs0 = α4 × cs0, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α4) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = α4 + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs0, α4, cs0
| _cs0 = α4 × cs0, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α4) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = α4 + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = α ^ + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cendstate(_cs1)) ∧ cactstream(_cs1) = α ^ + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cendstate(_cs1) ∧ cactstream(_cs1) = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs1 = α5 × cs1, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs1 ∧ α5 = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs1, α5, cs1
| _cs1 = α5 × cs1, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs1 ∧ α5 = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cendstate(_cs2) ∧ cactstream(_cs2) = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = cactstream(_cs2) ∧ (cactstream(_cs2) = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs2 = α6 × cs2, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α6 ∧ (α6 = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs2, α6, cs2
| _cs2 = α6 × cs2, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α6 ∧ (α6 = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cendstate(_cs4)) ∧ cactstream(_cs4) = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = cactstream(_cs4) ∧ (cactstream(_cs4) = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs4 = α7 × cs3, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cs3) ∧ α7 = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α7 = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs4, α7, cs3
| _cs4 = α7 × cs3, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cs3) ∧ α7 = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α7 = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cendstate(_cs3) ∧ cactstream(_cs3) = α1 ^ ∧ finp(cactstream(_cs3)) ∧ cmove(CIOAut(cstartf, cstepf))(cendstate(_cs3), ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = cactstream(_cs3) + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = cactstream(_cs3) ∧ (cactstream(_cs3) = [] → astartf(aσ.l.last))))) |
_cs3 = α8 × cs4, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α8) ∧ cmove(CIOAut(cstartf, cstepf))(cs4, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α8 + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α8 ∧ (α8 = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ ασ = cactstream(αs) ∧ st = cendstate(αs) ↔ αs = ασ × st; (elim) Used terms: _cs3, α8, cs4
| _cs3 = α8 × cs4, C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α8) ∧ cmove(CIOAut(cstartf, cstepf))(cs4, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α8 + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α8 ∧ (α8 = [] → astartf(aσ.l.last))))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last)))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last))))) |
⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α))
∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last)))))
Used terms: astepf, astartf, cstepf, cstartf
| ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)) |
| ∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last))))) |
∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last)))))
Used simplifier rules: ⊦ atrace*(AIOAut(startf, stepf))(α) ↔ atrace(AIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ctrace*(CIOAut(startf, stepf))(α) ↔ ctrace(CIOAut(startf, stepf))(α) ∧ finp(α); (s)
| ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ (α3 = [] ∧ cstartf(cs) → (∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs0 ∧ α4 = α ^ ∧ finp(α ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1) ∧ α5 = α ^ + ⌜a '⌝ ^ → (∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ0, α0) ∧ cstartf(cσ0[0]) ∧ finp(α0) ∧ cσ0.l.last = cs2 ∧ α6 = α0 ^ → (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)))) ∧ ( cfrag(CIOAut(cstartf, cstepf))(cσ1, α1) ∧ cstartf(cσ1[0]) ∧ finp(α1) ∧ cσ1.l.last = cs4 ∧ α8 = α1 ^ ∧ finp(α1 ^) ∧ cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3) ∧ α2 ^ = α1 ^ + ⌜a0 '⌝ ^ ∧ afrag(AIOAut(astartf, astepf))(aσ, α2) ∧ astartf(aσ[0]) ∧ finp(α2) ∧ aσ.l.last = as0 ∧ α2 ^ = α7 ∧ (α2 ^ = [] → astartf(aσ.l.last)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last))))) |
α3 = [], cstartf(cs), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^
cσ.l.last = cs0, α4 = α ^, α5 = α ^ + ⌜a '⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1), cstartf(cσ[0]), finp(α), finp(α ^), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^
cσ0.l.last = cs2, α6 = α0 ^, cfrag(CIOAut(cstartf, cstepf))(cσ0, α0), cstartf(cσ0[0]), finp(α0), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last))
cσ1.l.last = cs4, aσ.l.last = as0, α2 ^ = α1 ^ + ⌜a0 '⌝ ^, α2 ^ = α7, α8 = α1 ^, afrag(AIOAut(astartf, astepf))(aσ, α2), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, α1), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), finp(α1), finp(α1 ^), finp(α2), α2 ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last)))
| α3 = [], cstartf(cs), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^ |
cstartf(cs), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^
| cstartf(cs), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α. cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ cstartf(cσ[0]) ∧ finp(α) ∧ cσ.l.last = cs ∧ [] = α ^ |
Used simplifier rules: ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ finp([]); (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) ⊦ [] ^ = []; (s) Used terms: ⌜cs '⌝ , []
| cσ.l.last = cs0, α4 = α ^, α5 = α ^ + ⌜a '⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1), cstartf(cσ[0]), finp(α), finp(α ^), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ α ^ + ⌜a '⌝ ^ = α0 ^ |
⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ ⌜al0⌝ + ⌜a '⌝ ^ = α0 ^
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ.l.last, ⌜a '⌝ ^, cs1), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ ⌜al0⌝ + ⌜a '⌝ ^ = α0 ^ |
⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∃ α, sl. cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cσ.l.last = sl[0] ∧ cs1 = sl.last ∧ α ^ = ⌜a '⌝ ^ ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ ⌜al0⌝ + ⌜a '⌝ ^ = α0 ^
Used terms: cs1, ⌜a '⌝ ^, cσ.l.last, cstepf, cstartf
| ⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∃ α, sl. cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cσ.l.last = sl[0] ∧ cs1 = sl.last ∧ α ^ = ⌜a '⌝ ^ ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = cs1 ∧ ⌜al0⌝ + ⌜a '⌝ ^ = α0 ^ |
cσ.l.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ cfrag*(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| cσ.l.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^ |
cσ.l.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, cσ = ⌜csl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| cσ.l.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, cσ = ⌜csl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^ |
csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ .l = x; (s)
| csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ cσ, α0. cfrag(CIOAut(cstartf, cstepf))(cσ, α0) ∧ cstartf(cσ[0]) ∧ finp(α0) ∧ cσ.l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = α0 ^ |
csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0 + tl(csl)⌝ , ⌜al + al1⌝ ) ∧ cstartf(⌜csl0 + tl(csl)⌝ [0]) ∧ finp(⌜al + al1⌝ ) ∧ ⌜csl0 + tl(csl)⌝ .l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = ⌜al + al1⌝ ^
Used terms: ⌜csl0 + tl(csl)⌝ , ⌜al + al1⌝
| csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0 + tl(csl)⌝ , ⌜al + al1⌝ ) ∧ cstartf(⌜csl0 + tl(csl)⌝ [0]) ∧ finp(⌜al + al1⌝ ) ∧ ⌜csl0 + tl(csl)⌝ .l.last = csl.last ∧ ⌜al0⌝ + ⌜al1⌝ ^ = ⌜al + al1⌝ ^ |
csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜tl(csl)⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + tl(csl))[0]) ∧ (csl0 + tl(csl)).last = csl.last
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) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[histC-IOstatestream] ⊦ ⌜x⌝ .l = x; (s) finp(σ) ⊦ (⌜x⌝ + σ).l = x + σ.l; (s) ⊦ finp(⌜x⌝ ); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s)
| csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜tl(csl)⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + tl(csl))[0]) ∧ (csl0 + tl(csl)).last = csl.last |
csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, csl = cs + csl1, ⌜al0⌝ = ⌜al⌝ ^, csl ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + csl1)[0]) ∧ (csl0 + csl1).last = csl.last
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl, cs, csl1
| csl0.last = csl[0], ⌜al1⌝ ^ = ⌜a '⌝ ^, csl = cs + csl1, ⌜al0⌝ = ⌜al⌝ ^, csl ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + csl1)[0]) ∧ (csl0 + csl1).last = csl.last |
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + csl1)[0]) ∧ (csl0 + csl1).last = (csl0.last ' + csl1).last
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s) ⊦ (a ' + x)[0] = a; (s)
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ) ∧ cstartf((csl0 + csl1)[0]) ∧ (csl0 + csl1).last = (csl0.last ' + csl1).last |
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ¬ cstartf((csl0 + csl1)[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, (csl0 + csl1).last ≠ (csl0.last ' + csl1).last, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
cfrag(CIOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), cfrag(CIOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), sl0[0] = sl.last ⊦ cfrag(CIOAut(startf, stepf))(⌜sl.butlast⌝ + ⌜sl0⌝ , ⌜al⌝ + ⌜al0⌝ )
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.butlast⌝ + ⌜csl0.last ' + csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] Used terms: cstartf, cstepf, csl0, al, csl0.last ' + csl1, al1
| cfrag(CIOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), cfrag(CIOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), sl0[0] = sl.last ⊦ cfrag(CIOAut(startf, stepf))(⌜sl.butlast⌝ + ⌜sl0⌝ , ⌜al⌝ + ⌜al0⌝ ) |
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.butlast⌝ + ⌜csl0.last ' + csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.butlast⌝ + ⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[histC-IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.butlast⌝ + ⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ (σ + σ1) + σ2 = σ + σ1 + σ2
⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))((⌜csl0.butlast⌝ + ⌜csl0.last '⌝ ) + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used terms: ⌜csl1⌝ , ⌜csl0.last '⌝ , ⌜csl0.butlast⌝
| ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2 |
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))((⌜csl0.butlast⌝ + ⌜csl0.last '⌝ ) + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜csl1⌝ , ⌜al⌝ + ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ x.butlast + x.last ' = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] Used terms: csl0.last ', csl0.butlast
| ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ |
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ¬ cstartf((csl0 + csl1)[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, csl1, csl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| ⌜al1⌝ ^ = ⌜a '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, (csl0 + csl1).last ≠ (csl0.last ' + csl1).last, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0.last '⌝ + ⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ y ≠ [] → (x + y).last = y.last
Used simplifier rules: ⊦ x ≠ [] → (a ' + x).last = x.last; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[histC-IOstatestream] ⊦ x + [] = x; (s) ⊦ a '.last = a; (s) Used terms: csl1, csl0
| ⊦ y ≠ [] → (x + y).last = y.last |
| cσ0.l.last = cs2, α6 = α0 ^, cfrag(CIOAut(cstartf, cstepf))(cσ0, α0), cstartf(cσ0[0]), finp(α0), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = α0 ^ ∧ (α0 ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(cσ0, ⌜al⌝ ), cstartf(cσ0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| cfrag(CIOAut(cstartf, cstepf))(cσ0, ⌜al⌝ ), cstartf(cσ0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cσ0 = ⌜csl0⌝ , cfrag(CIOAut(cstartf, cstepf))(cσ0, ⌜al⌝ ), cstartf(cσ0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| cσ0 = ⌜csl0⌝ , cfrag(CIOAut(cstartf, cstepf))(cσ0, ⌜al⌝ ), cstartf(cσ0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used terms: ⌜al⌝ ^
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used terms: ⌜al⌝ ^, cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) Used terms: ⌜csl0⌝ , ⌜al⌝
| atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used terms: ⌜al⌝ ^, astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used terms: α, ⌜al⌝ ^.l
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []) ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ finp(⌜al⌝ ^); (s) ⊦ finp([]); (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ σ + σ0 = σ ↔ σ0 = [] ∨ # σ = ∞; (s) ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ ⌜al1⌝ ^.l = [] ↔ ⌜al1⌝ ^ = []; (s)
| ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
α ^ = [], ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last))
Used formulas: α ^ ≠ []
| ⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ α ^ = ⌜al0⌝ ^
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ x + [] = x; (s) ⊦ [].l = []; (s)
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ α ^ = ⌜al0⌝ ^ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1)[0]) ∧ finp(⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al0⌝ ^
Used terms: aσ to # al0 + 1, ⌜al0⌝
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1)[0]) ∧ finp(⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al0⌝ ^ |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1)[0])
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1)[0]) |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ⊦
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astartf((aσ to # al0 + 1)[0]) ⊦
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), #(aσ to # al0 + 1) ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf((aσ to # al0 + 1)[n], ⌜al0⌝ [n], (aσ to # al0 + 1)[n +1]))) ⊦
Used terms: ⌜al0⌝ , aσ to # al0 + 1, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), #(aσ to # al0 + 1) ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf((aσ to # al0 + 1)[n], ⌜al0⌝ [n], (aσ to # al0 + 1)[n +1]))) ⊦ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
Used simplifier rules: ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
Used terms: ⌜al0⌝ + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
Used simplifier rules: ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], # aσ < ⌜# al0 + 1⌝ , astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ # aσ < ⌜# al0 + 1⌝ , ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), ⌜# al0 + 1⌝ ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
Used terms: # al0 + 1, aσ
| ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ |
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], # aσ < ⌜# al0 + 1⌝ , astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦
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⌝ + ⌜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)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
Used simplifier rules: ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (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
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ # aσ < ⌜# al0 + 1⌝ , ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), ⌜# al0 + 1⌝ ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, ⌜# al0⌝ < # aσ, astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[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⌝ + ⌜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) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (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)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, ⌜# al0⌝ < # aσ, astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]) ⊦ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], ⌜# al0⌝ < # aσ, n < # al0, astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦
Used terms: n
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], ⌜# al0⌝ < # aσ, n < # al0, astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦ |
⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m]
Used simplifier rules: ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ m < n → ⌜m⌝ < ⌜n⌝ + 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 ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: n, α0, ⌜al0⌝
| ⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m] |
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ astartf((aσ to # al0 + 1)[0]) ⊦ |
⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n)
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]) ⊦
Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ (⌜a '⌝ + σ)[0] = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] Used terms: # al0, aσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n) |
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]) ⊦ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]) ⊦
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]) ⊦
Used terms: ⌜al0⌝ + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]) ⊦ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦
Used simplifier rules: ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦ |
Used simplifier rules: ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (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
| α ^ = [], ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), α ^ ≠ [] → α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ al0.last = (⌜al0⌝ ^.l + α0 ^.l).last ∧ α0 ^ = [] ⊦ ∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ α ^ = ⌜al⌝ ^ ∧ (⌜al⌝ ^ = [] → astartf(aσ.l.last)) |
α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ0, α0. afrag(AIOAut(astartf, astepf))(aσ0, α0) ∧ astartf(aσ0[0]) ∧ finp(α0) ∧ α0 ^ = [] ∧ astartf(aσ0.l.last)
| α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]) ⊦ ∃ aσ0, α0. afrag(AIOAut(astartf, astepf))(aσ0, α0) ∧ astartf(aσ0[0]) ∧ finp(α0) ∧ α0 ^ = [] ∧ astartf(aσ0.l.last) |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ finp([]); (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) Used terms: ⌜aσ[0] '⌝ , []
| cσ1.l.last = cs4, aσ.l.last = as0, α2 ^ = α1 ^ + ⌜a0 '⌝ ^, α2 ^ = α7, α8 = α1 ^, afrag(AIOAut(astartf, astepf))(aσ, α2), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, α1), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), finp(α1), finp(α1 ^), finp(α2), α2 ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ, α. afrag(AIOAut(astartf, astepf))(aσ, α) ∧ astartf(aσ[0]) ∧ finp(α) ∧ aσ.l.last = as ∧ α ^ = α1 ^ ∧ (α1 ^ = [] → astartf(aσ.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, aσ = ⌜asl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: astatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ afrag(AIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, aσ = ⌜asl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(aσ.l.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, aσ.l.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, cσ1 = ⌜csl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, cσ1 = ⌜csl0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(cσ1, ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(cσ1.l.last, ⌜a0 '⌝ ^, cs3), cstartf(cσ1[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ ^, cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ ^, cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, a0 = τ, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ ^, cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used terms: a0
| ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ |
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ ^, a0 = τ, ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ ^, cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ ^, asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ⌜τ '⌝ ^ = []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s)
| ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(asl0.last, [], asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0.last ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used terms: asl0.last
| ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(asl0.last, [], asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0.last ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0.last ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))
Used simplifier rules: ⊦ amove(AIOAut(startf, stepf))(s, [], s); (s)
| ⌜al1⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, [], cs3), cstartf(csl0[0]), al0 = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0.last ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)) |
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ .l = x; (s) Used terms: ⌜asl0⌝ , ⌜al1⌝
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⊦ α ^ = ⌜al⌝ + β2 → (∃ α1, α2. α1 ^ = ⌜al⌝ ∧ α2 ^ = β2 ∧ α1 + α2 = α)
⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ → (∃ α1, α2. α1 ^ = ⌜al0⌝ ∧ α2 ^ = ⌜a0 '⌝ ∧ α1 + α2 = ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used terms: ⌜al1⌝ , al0, ⌜a0 '⌝
| ⊦ α ^ = ⌜al⌝ + β2 → (∃ α1, α2. α1 ^ = ⌜al⌝ ∧ α2 ^ = β2 ∧ α1 + α2 = α) |
| ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ → (∃ α1, α2. α1 ^ = ⌜al0⌝ ∧ α2 ^ = ⌜a0 '⌝ ∧ α1 + α2 = ⌜al1⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
α1 + α2 = ⌜al1⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , α2 ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
| α1 + α2 = ⌜al1⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , α2 ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
α1 + α2 = ⌜al1⌝ , α2 ^ = ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α2 = ⌜al2⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜x⌝ ≠ σ + ⌜nf0⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]
| α1 + α2 = ⌜al1⌝ , α2 ^ = ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α2 = ⌜al2⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
α1 + ⌜al2⌝ = ⌜al1⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
| α1 + ⌜al2⌝ = ⌜al1⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
α1 + ⌜al2⌝ = ⌜al1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 = ⌜al3⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ + σ = ⌜nf⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ ≠ ⌜nf⌝ ; (s)
| α1 + ⌜al2⌝ = ⌜al1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , α1 ^ = ⌜al0⌝ , ⌜al1⌝ ^ = ⌜al0⌝ + ⌜a0 '⌝ , α1 = ⌜al3⌝ , ⌜al0⌝ = ⌜al⌝ ^, a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ⌜al1⌝ ^ = [] → astartf(asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ a ' ≠ []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ (⌜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)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , al0 = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last)))
Used formulas: al0 = []
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , al0 = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
[] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [] ∧ astartf(aσ0.l.last))
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ a ' ≠ []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ [] + σ = σ; (s)
| [] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [] ∧ astartf(aσ0.l.last)) |
[] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(hd(asl0), ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = hd(asl0) ∧ α ^ = [] ∧ astartf(aσ0.l.last))
Used terms: hd(asl0)
| [] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(hd(asl0), ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = hd(asl0) ∧ α ^ = [] ∧ astartf(aσ0.l.last)) |
[] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], asl0 = as + asl, a0 ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [] ∧ astartf(aσ0.l.last))
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as, asl
| [] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], asl0 = as + asl, a0 ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [] ∧ astartf(aσ0.l.last)) |
[] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , (as ' + asl).last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [])
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a ' + x ≠ []; (s)
| [] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , (as ' + asl).last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = []) |
[] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , (as ' + asl).last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
[] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = []
| [] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , (as ' + asl).last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
[] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as = sl[0] ∧ (as ' + asl).last = sl.last ∧ α ^ = ⌜a0 '⌝ ) ⊦
Used terms: (as ' + asl).last, ⌜a0 '⌝ , as, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| [] = ⌜al⌝ ^, ⌜al3⌝ ^ = [], ⌜al2⌝ ^ = ⌜a0 '⌝ , a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as = sl[0] ∧ (as ' + asl).last = sl.last ∧ α ^ = ⌜a0 '⌝ ) ⊦ |
[] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ (sl[0] ' + asl).last ≠ sl.last ∨ α ^ ≠ ⌜a0 '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| [] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ (sl[0] ' + asl).last ≠ sl.last ∨ α ^ ≠ ⌜a0 '⌝ ⊦ |
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ finp(⌜x⌝ ); (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a + x = a ' + x; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ [] + σ = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) Used terms: ⌜al3⌝ + ⌜al2⌝ , as + asl
| [] = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = [], a0 ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = [] |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ finp([]); (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) ⊦ [] ^ = []; (s) Used terms: ⌜as '⌝ , []
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ∧ (al0 = [] → astartf(aσ0.l.last))) |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ )
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = as ∧ α ^ = ⌜al0⌝ ) |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(asl0[# al3], ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0[# al3] ∧ α ^ = ⌜al0⌝ )
Used terms: asl0[# al3]
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ amove(AIOAut(astartf, astepf))(asl0[# al3], ⌜a0 '⌝ , asl0.last) ∧ (∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0[# al3] ∧ α ^ = ⌜al0⌝ ) |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ amove(AIOAut(astartf, astepf))(asl0[# al3], ⌜a0 '⌝ , asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0[# al3] ∧ α ^ = ⌜al0⌝
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ amove(AIOAut(astartf, astepf))(asl0[# al3], ⌜a0 '⌝ , asl0.last), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[# al3] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a0 '⌝ ) ⊦
Used terms: asl0.last, ⌜a0 '⌝ , asl0[# al3], astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[# al3] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a0 '⌝ ) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[# al3] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a0 '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[# al3] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a0 '⌝ ⊦ |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ ¬ finp(⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ∨ ⌜al2⌝ ^ ≠ ⌜a0 '⌝ ⊦
Used terms: ⌜al2⌝ , asl0 from # al3
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ ¬ finp(⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ∨ ⌜al2⌝ ^ ≠ ⌜a0 '⌝ ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # al3 + 0 < # asl0, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], # al3 + 0 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ asl0[# al3 + 0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
Used terms: 0, # al3, asl0
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # al3 + 0 < # asl0, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
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)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl0⌝ = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf(⌜asl0⌝ [n], (⌜al3⌝ + ⌜al2⌝ )[n], ⌜asl0⌝ [n +1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
Used terms: ⌜al3⌝ + ⌜al2⌝ , ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl0⌝ = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf(⌜asl0⌝ [n], (⌜al3⌝ + ⌜al2⌝ )[n], ⌜asl0⌝ [n +1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦
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)
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ (asl0 from # al3)[0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
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
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], # al3 + 0 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0[# al3] ≠ asl0[# al3 + 0] ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], asl0 ≠ [], # al3 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0.last ≠ (asl0 from # al3).last ⊦
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)
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], asl0 ≠ [], # al3 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , asl0 = as + asl, ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], asl0 ≠ [], # al3 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0.last ≠ (asl0 from # al3).last ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as, asl
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , asl0 = as + asl, ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], asl0 ≠ [], # al3 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al3⌝ , ⌜al2⌝ ) ∨ asl0.last ≠ (asl0 from # al3).last ⊦ |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜as ' + asl from # al3⌝ , ⌜al2⌝ ) ∨ (as ' + asl).last ≠ (as ' + asl from # al3).last ⊦
Used simplifier rules: ⊦ 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) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ¬ afrag(AIOAut(astartf, astepf))(⌜as ' + asl from # al3⌝ , ⌜al2⌝ ) ∨ (as ' + asl).last ≠ (as ' + asl from # al3).last ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ afrag(AIOAut(astartf, astepf))(⌜as ' + asl from # al3⌝ , ⌜al2⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (as ' + asl).last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ afrag(AIOAut(astartf, astepf))(⌜as ' + asl from # al3⌝ , ⌜al2⌝ ), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # ⌜as ' + asl from # al3⌝ ≠ # ⌜al2⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al2⌝ → astepf(⌜as ' + asl from # al3⌝ [n], ⌜al2⌝ [n], ⌜as ' + asl from # al3⌝ [n +1]))) ⊦
Used terms: ⌜al2⌝ , ⌜as ' + asl from # al3⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # ⌜as ' + asl from # al3⌝ ≠ # ⌜al2⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al2⌝ → astepf(⌜as ' + asl from # al3⌝ [n], ⌜al2⌝ [n], ⌜as ' + asl from # al3⌝ [n +1]))) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # asl - # al3 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-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 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m ≤ n → (n < m ↔ false); (s) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ m ≤ m + 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 let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m < n → ¬ n < m; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m < n → n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n + 1 ↔ ¬ n < 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) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ ¬ m + n < m; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # asl - # al3 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦ |
# asl = n0 + # al3, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), n0 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦
Used simplifier rules: n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # asl, # al3, n0
| # asl = n0 + # al3, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), n0 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
#(⌜as '⌝ + ⌜asl⌝ ) = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , # asl = n0 + # al3, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf((⌜as '⌝ + ⌜asl⌝ )[n], (⌜al3⌝ + ⌜al2⌝ )[n], (⌜as '⌝ + ⌜asl⌝ )[n +1]), n0 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦
Used terms: ⌜al3⌝ + ⌜al2⌝ , ⌜as '⌝ + ⌜asl⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| #(⌜as '⌝ + ⌜asl⌝ ) = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , # asl = n0 + # al3, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf((⌜as '⌝ + ⌜asl⌝ )[n], (⌜al3⌝ + ⌜al2⌝ )[n], (⌜as '⌝ + ⌜asl⌝ )[n +1]), n0 ≠ # al2 ∨ ¬(n < # al2 → astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n])) ⊦ |
# asl = # al2 + # al3, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al2 ≠ [], n < # al2, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n1. n1 < # asl → astepf((as ' + asl)[n1], (al3 + al2)[n1], asl[n1]) ⊦
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 eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜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)
| # asl = # al2 + # al3, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al2 ≠ [], n < # al2, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ astepf((as ' + asl)[# al3 + n], al2[n], asl[# al3 + n]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n1. n1 < # asl → astepf((as ' + asl)[n1], (al3 + al2)[n1], asl[n1]) ⊦ |
Used simplifier rules: ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ (x + y)[n + # x] = y[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[actionstream] Used terms: # al3 + n
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (as ' + asl).last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ x ≠ [] → (a ' + x).last = x.last
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], asl.last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ a '.last = a; (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ # [] = 0; (s) ⊦ m ≤ 0 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ σ + [] = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) Used terms: asl, as
| ⊦ x ≠ [] → (a ' + x).last = x.last |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], asl.last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], asl.last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], asl.last ≠ (as ' + asl from # al3).last, a0 ≠ τ, al0 ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , asl = asl0 + as0 ', ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl from # al3).last, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: asl, as0, asl0
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , asl = asl0 + as0 ', ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl from # al3).last, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ n ≤ # x → x + y from n = (x from n) + y
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ¬ # al3 ≤ # as ', ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: # al3, asl0 + as0 ', as '
| ⊦ n ≤ # x → x + y from n = (x from n) + y |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ¬ # al3 ≤ # as ', ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ # a ' = 0 +1; (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (as ' + asl0 + as0 ' from # al3).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ # x < n → x + y from n = y from (n - # x)
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (asl0 + as0 ' from (# al3 - # as ')).last, # as ' < # al3, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ # x = 0 ↔ x = []; (s) Used terms: # al3, asl0 + as0 ', as '
| ⊦ # x < n → x + y from n = y from (n - # x) |
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (asl0 + as0 ' from (# al3 - # as ')).last, # as ' < # al3, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (asl0 + as0 ' from (# al3 - 1)).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ # a ' = 0 +1; (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, # al3 ≠ 1, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], as0 ≠ (asl0 + as0 ' from (# al3 - 1)).last, afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ + ⌜as0 '⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl0 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) ⊦ 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 ⊦ 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[traceA-IOstatestream] n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # al3, m
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ ∃ aσ0, α. afrag(AIOAut(astartf, astepf))(aσ0, α) ∧ astartf(aσ0[0]) ∧ finp(α) ∧ aσ0.l.last = asl0[# al3] ∧ α ^ = ⌜al0⌝ |
⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf(⌜asl0 to # al3 + 1⌝ [0]) ∧ finp(⌜al3⌝ ) ∧ ⌜asl0 to # al3 + 1⌝ .l.last = asl0[# al3] ∧ ⌜al3⌝ ^ = ⌜al0⌝
Used terms: ⌜asl0 to # al3 + 1⌝ , ⌜al3⌝
| ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf(⌜asl0 to # al3 + 1⌝ [0]) ∧ finp(⌜al3⌝ ) ∧ ⌜asl0 to # al3 + 1⌝ .l.last = asl0[# al3] ∧ ⌜al3⌝ ^ = ⌜al0⌝ |
⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3]
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al3⌝ + ⌜al2⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3] |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl0⌝ = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf(⌜asl0⌝ [n], (⌜al3⌝ + ⌜al2⌝ )[n], ⌜asl0⌝ [n +1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3]
Used terms: ⌜al3⌝ + ⌜al2⌝ , ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl0⌝ = #(⌜al3⌝ + ⌜al2⌝ ) + ⌜1⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. ⌜n⌝ < #(⌜al3⌝ + ⌜al2⌝ ) → astepf(⌜asl0⌝ [n], (⌜al3⌝ + ⌜al2⌝ )[n], ⌜asl0⌝ [n +1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3] |
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3]
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)
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ) ∧ astartf((asl0 to # al3 + 1)[0]) ∧ (asl0 to # al3 + 1).last = asl0[# al3] |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astartf((asl0 to # al3 + 1)[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al3 + 1⌝ , ⌜al3⌝ ), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # ⌜asl0 to # al3 + 1⌝ ≠ # ⌜al3⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al3⌝ → astepf(⌜asl0 to # al3 + 1⌝ [n], ⌜al3⌝ [n], ⌜asl0 to # al3 + 1⌝ [n +1]))) ⊦
Used terms: ⌜al3⌝ , ⌜asl0 to # al3 + 1⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # ⌜asl0 to # al3 + 1⌝ ≠ # ⌜al3⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al3⌝ → astepf(⌜asl0 to # al3 + 1⌝ [n], ⌜al3⌝ [n], ⌜asl0 to # al3 + 1⌝ [n +1]))) ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦
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)
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦ |
¬ # x < n ⊦ #(x to n) = n
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], # asl0 < # al3 + 1, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # asl0 < # al3 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # al3 + 1 ≠ # al3 + 1 ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦
Used terms: # al3 + 1, asl0
| ¬ # x < n ⊦ #(x to n) = n |
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], # asl0 < # al3 + 1, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦
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)
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), # al3 + 1 ≠ #(asl0 to # al3 + 1) ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦ |
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
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # asl0 < # al3 + 1, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), # al3 + 1 ≠ # al3 + 1 ∨ ¬(n < # al3 → astepf((asl0 to # al3 + 1)[n], al3[n], (asl0 to # al3 + 1)[n + 1])) ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl0 ≠ [], n < # al3 + # al2, n < # asl0, n < # al3, # al3 < # asl0, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astepf(asl0[n], al3[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦
Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m < n → ¬ n < m; (s) 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 < m + n0 ↔ n < n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ ¬ m + n < m; (s) ⊦ m +1 = m + 1; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # x = 0 ↔ x = []; (s) trans: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s)
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl0 ≠ [], n < # al3 + # al2, n < # asl0, n < # al3, # al3 < # asl0, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astepf(asl0[n], al3[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , asl0 = as + asl, ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl0 ≠ [], # al3 < # asl0, n < # al3, n < # asl0, n < # al3 + # al2, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astepf(asl0[n], al3[n], asl0[n + 1]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as, asl
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , asl0 = as + asl, ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl0 ≠ [], # al3 < # asl0, n < # al3, n < # asl0, n < # al3 + # al2, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astepf(asl0[n], al3[n], asl0[n + 1]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
# al3 + # al2 = # asl, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl ≠ [], n < # asl, n < # al3, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ astepf((as ' + asl)[n], al3[n], asl[n]), ∀ n0. n0 < # asl → astepf((as ' + asl)[n0], (al3 + al2)[n0], asl[n0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ m < n → m ≤ 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 fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-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) ⊦ a + x = a ' + x; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s) ⊦ m + n = m + n0 ↔ n = n0; (s)
| # al3 + # al2 = # asl, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], al3 ≠ [], asl ≠ [], n < # asl, n < # al3, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # al3 ≤ # asl, ¬ astepf((as ' + asl)[n], al3[n], asl[n]), ∀ n0. n0 < # asl → astepf((as ' + asl)[n0], (al3 + al2)[n0], asl[n0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
Used simplifier rules: ⊦ n < # x → (x + y)[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: n
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astartf((asl0 to # al3 + 1)[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
¬ # x < n, m < n ⊦ (x to n)[m] = x[m]
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astartf((asl0 to # al3 + 1)[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ ¬ # asl0 < # al3 + 1 ∧ 0 < # al3 + 1
Used terms: 0, # al3 + 1, asl0
| ¬ # x < n, m < n ⊦ (x to n)[m] = x[m] |
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ astartf((asl0 to # al3 + 1)[0]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ ¬ # asl0 < # al3 + 1 ∧ 0 < # al3 + 1 |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ¬ astartf((asl0 to # al3 + 1)[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
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)
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ¬ astartf((asl0 to # al3 + 1)[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
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
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
m < # x ⊦ x to m + 1 = (x to m) + x[m] '
# al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # al3 < # asl0, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦
Used simplifier rules: ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: # al3, asl0
| m < # x ⊦ x to m + 1 = (x to m) + x[m] ' |
| # al3 + # al2 + 1 = # asl0, ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), ¬ # al3 < # asl0, ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9), ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]) ⊦ |
# al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # al3 + # al2 + 1 = # asl0, ⌜al2⌝ ^ = ⌜a0 '⌝ , ⌜al3⌝ ^ = ⌜al0⌝ , ⌜al0⌝ = ⌜al⌝ ^, ⌜al0⌝ + ⌜a0 '⌝ ≠ [], (asl0 to # al3 + 1).last ≠ asl0[# al3], a0 ≠ τ, al0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cmove(CIOAut(cstartf, cstepf))(csl0.last, ⌜a0 '⌝ , cs3), cstartf(csl0[0]), # asl0 ≤ # al3, ∀ n. n < # al3 + # al2 → astepf(asl0[n], (al3 + al2)[n], asl0[n + 1]), ∀ α9. ctrace(CIOAut(cstartf, cstepf))(α9) ∧ finp(α9) → atrace(AIOAut(astartf, astepf))(α9) ⊦ |
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
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.