| fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), cexec*(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ aexec*(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
cexec*(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ aexec*(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
| cexec*(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ aexec*(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: <; (wellfounded) Used terms: # al
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
al = [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used formulas: al = []
| al = [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , []), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used simplifier rules: ⊦ [] ^ = []; (s) ⊦ ⌜[]⌝ = []; (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , []), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜csl⌝ = # [] + ⌜1⌝ , cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ n. ⌜n⌝ < # [] → cstepf(⌜csl⌝ [n], [][n], ⌜csl⌝ [n +1]), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used terms: [], ⌜csl⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜csl⌝ = # [] + ⌜1⌝ , cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ n. ⌜n⌝ < # [] → cstepf(⌜csl⌝ [n], [][n], ⌜csl⌝ [n +1]), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
# csl = 1, cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # csl = 1, cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
# csl = 1, csl = cs0 + csl0, cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used simplifier rules: cstatelist freely generated by [], +;; ⊦ # [] = 0; (s)
| # csl = 1, csl = cs0 + csl0, cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
cstartf(cs0), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used simplifier rules: ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ x + [] = x; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)
| cstartf(cs0), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))
cstartf(cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used terms: r, astepf, astartf, cstepf, cstartf
| ⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0))) |
| cstartf(cs0), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
cstartf(cs0), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
| cstartf(cs0), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
cstartf(cs0), cstartf(cs0) → (∃ as. r(as, cs0) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
Used terms: cs0
| cstartf(cs0), cstartf(cs0) → (∃ as. r(as, cs0) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
astartf(as), cstartf(cs0), r(as, cs0), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
| astartf(as), cstartf(cs0), r(as, cs0), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # [] → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs0) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
Used simplifier rules: ⊦ a '.last = a; (s) ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) Used terms: as ', []
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r)
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∃ asl, al1. r(asl.last, csl.butlast.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ x ≠ [] → # x.butlast = # x - 1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ n < n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: al.butlast, cstartf, cstepf, csl.butlast, astartf, astepf, r
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) |
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0])
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^, cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0]) |
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0])
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl.butlast⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl.butlast[0]) |
csl = csl0 + cs ', al ≠ [], csl ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl0[0])
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: csl, cs, y
| csl = csl0 + cs ', al ≠ [], csl ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl0[0]) |
al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl0[0])
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al.butlast⌝ ) ∧ cstartf(csl0[0]) |
al = al2 + a ', al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0])
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: al, a, y
| al = al2 + a ', al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al2⌝ + ⌜a '⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0])
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs '⌝ , ⌜al2⌝ + ⌜a '⌝ ), cstartf((csl0 + cs ')[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) |
⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α)
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs ')[0]), cstepf(csl0.last, a, cs), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0])
Used terms: a, ⌜al2⌝ , cs, csl0, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs ')[0]), cstepf(csl0.last, a, cs), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs ')[0]), cstepf(csl0.last, a, cs), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ¬ cstartf(csl0[0]), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs ')[0]), cstepf(csl0.last, a, cs), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ¬ cstartf(csl0[0]), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, cs ', csl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| al ≠ [], cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), ∃ asl, al1. r(asl.last, csl.butlast.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), r(asl.last, csl.butlast.last), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r), r(asl.last, csl.butlast.last), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(asl.last, csl.butlast.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used terms: r, astepf, astartf, cstepf, cstartf
| ⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0))) |
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(asl.last, csl.butlast.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(asl.last, csl.butlast.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(asl.last, csl.butlast.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, asl = asl0 + as1 ', al ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl.butlast.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: asl, as1, y
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, asl = asl0 + as1 ', al ≠ [], asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl.butlast.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl.butlast.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl.butlast.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, csl = csl0 + cs1 ', al ≠ [], csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: csl, cs1, y
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, csl = csl0 + cs1 ', al ≠ [], csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al1⌝ ^ = ⌜al.butlast⌝ ^, al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, al = al2 + a0 ', al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: al, a0, y
| ⌜al1⌝ ^ = ⌜al2⌝ ^, al = al2 + a0 ', al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < # al → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), cstartf((csl0 + cs1 ')[0]), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α)
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
Used terms: a0, ⌜al2⌝ , cs1, csl0, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α) |
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), r(as1, csl0.last) ∧ cstepf(csl0.last, a0, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as1, ⌜a0 '⌝ ^, as0) ∧ r(as0, cs1)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
Used terms: csl0.last, a0, cs1, as1
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), r(as1, csl0.last) ∧ cstepf(csl0.last, a0, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as1, ⌜a0 '⌝ ^, as0) ∧ r(as0, cs1)), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), amove(AIOAut(astartf, astepf))(as1, ⌜a0 '⌝ ^, as0), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), r(as0, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), amove(AIOAut(astartf, astepf))(as1, ⌜a0 '⌝ ^, as0), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as1, csl0.last), r(as0, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as0, cs1), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as0 = sl.last ∧ α ^ = ⌜a0 '⌝ ^, ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^
Used terms: as0, ⌜a0 '⌝ ^, as1, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as1 '⌝ , ⌜al1⌝ ), astartf((asl0 + as1 ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(as0, cs1), r(as1, csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as0 = sl.last ∧ α ^ = ⌜a0 '⌝ ^, ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜a0 '⌝ ^ |
⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜al⌝ ^
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ ∃ asl, al0. r(asl.last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al2⌝ ^ + ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0 + asl⌝ , ⌜al1 + al⌝ ) ∧ astartf((asl0 + asl)[0]) ∧ ⌜al1 + al⌝ ^ = ⌜al2⌝ ^ + ⌜al⌝ ^
Used terms: asl0 + asl, al1 + al
| ⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0 + asl⌝ , ⌜al1 + al⌝ ) ∧ astartf((asl0 + asl)[0]) ∧ ⌜al1 + al⌝ ^ = ⌜al2⌝ ^ + ⌜al⌝ ^ |
⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ) ∧ astartf((asl0 + asl)[0])
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) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ) ∧ astartf((asl0 + asl)[0]) |
afrag(AIOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), afrag(AIOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), sl0[0] = sl.last ⊦ afrag(AIOAut(startf, stepf))(⌜sl.butlast⌝ + ⌜sl0⌝ , ⌜al⌝ + ⌜al0⌝ )
⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜(asl0 + asl[0] ').butlast⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ) ∧ astartf((asl0 + asl)[0])
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: astartf, astepf, asl0 + asl[0] ', al1, asl, al
| afrag(AIOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), afrag(AIOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ), sl0[0] = sl.last ⊦ afrag(AIOAut(startf, stepf))(⌜sl.butlast⌝ + ⌜sl0⌝ , ⌜al⌝ + ⌜al0⌝ ) |
| ⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜(asl0 + asl[0] ').butlast⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ) ∧ astartf((asl0 + asl)[0]) |
⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ astartf((asl0 + asl)[0])
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').butlast = x; (s)
| ⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ astartf((asl0 + asl)[0]) |
⊦ n < # x → (x + y)[n] = x[n]
⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, 0 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ astartf(asl0[0])
Used simplifier rules: ⊦ ¬ n < # x → (x + y)[n] = y[n - # x]; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] + σ = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: 0, asl, asl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| ⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, 0 < # asl0, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf((asl0 + asl[0] ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ r((asl0 + asl).last, cs1) ∧ astartf(asl0[0]) |
⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ¬ r((asl0 + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s)
| ⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ¬ r((asl0 + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ |
⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, asl0 = as0 + asl1, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ¬ r((asl0 + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as0, y
| ⌜al⌝ ^ = ⌜a0 '⌝ ^, ⌜al1⌝ ^ = ⌜al2⌝ ^, asl0 = as0 + asl1, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl[0], csl0.last), r(asl.last, cs1), ¬ r((asl0 + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ |
⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((⌜as0 '⌝ + ⌜asl1⌝ ) + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))((⌜as0 '⌝ + ⌜asl1⌝ ) + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ¬ r(((as0 ' + asl1) + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a + x = a ' + x; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al1⌝ ^ = ⌜al2⌝ ^, ⌜al⌝ ^ = ⌜a0 '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((⌜as0 '⌝ + ⌜asl1⌝ ) + ⌜asl[0] '⌝ , ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))((⌜as0 '⌝ + ⌜asl1⌝ ) + ⌜asl⌝ , ⌜al1⌝ + ⌜al⌝ ), astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf((csl0 + cs1 ')[0]), cstepf(csl0.last, a0, cs1), r(asl.last, cs1), r(asl[0], csl0.last), ¬ r(((as0 ' + asl1) + asl).last, cs1), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ al0, cstartf, cstepf, csl, astartf, astepf, r. # al0 < #(al2 + a0 ') → cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) → (∃ asl, al1. r(asl.last, csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ |
⊦ y ≠ [] → (a ' + x + y).last = y.last
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: asl, asl1, as0
| ⊦ y ≠ [] → (a ' + x + y).last = y.last |
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.