| AIOAut?(AIOAut(astartf, astepf)) ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ asl, al0. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^)) |
AIOAut?(AIOAut(astartf, astepf)), C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ ∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ asl, al0. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^)
AIOAut?(AIOAut(astartf, astepf)), ¬ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ asl, al0. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
| AIOAut?(AIOAut(astartf, astepf)), C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ ∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ asl, al0. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) |
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: leqstar-def: ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)); ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ AIOAut?(AIOAut(startf, stepf)) ↔ (∃ s. startf(s)); (s) ⊦ atrace*(AIOAut(startf, stepf))(α) ↔ atrace(AIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ctrace*(CIOAut(startf, stepf))(α) ↔ ctrace(CIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used terms: ⌜al⌝ ^
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s)
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
astartf(as), atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used terms: ⌜al⌝ ^, cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) Used terms: ⌜csl⌝ , ⌜al⌝
| astartf(as), atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^
Used terms: ⌜al⌝ ^, astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ |
⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^ |
⌜al⌝ ^ = α ^, ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^
⌜al⌝ ^ = α ^, ⌜al⌝ ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^
Used formulas: ⌜al⌝ ^ = []
| ⌜al⌝ ^ = α ^, ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^ |
α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = []
| α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = [] |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) Used terms: aσ[0] ', []
| ⌜al⌝ ^ = α ^, ⌜al⌝ ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^ |
⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^
| ⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^ |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^
Used terms: α, ⌜al⌝ ^.l
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []) ⊦ ∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = α ^ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ x + [] = x; (s) ⊦ [].l = []; (s) finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ finp(⌜al⌝ ^); (s) ⊦ finp([]); (s) ⊦ σ + σ0 = σ ↔ σ0 = [] ∨ # σ = ∞; (s) ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ ⌜al1⌝ ^.l = [] ↔ ⌜al1⌝ ^ = []; (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^ |
⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n)
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0) ∧ ¬ #(⌜al0⌝ + α0) < ⌜# al0⌝ → afrag*(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ + α0 to # al0) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^
Used terms: astartf, astepf, aσ, ⌜al0⌝ + α0, # al0
| ⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n) |
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0) ∧ ¬ #(⌜al0⌝ + α0) < ⌜# al0⌝ → afrag*(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ + α0 to # al0) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + σ to # 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∞ + n∞1 < n∞1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ ∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^ |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ ⌜al0⌝ ^ = ⌜al0⌝ ^
Used terms: (aσ to # al0 + 1).l, al0
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ ⌜al0⌝ ^ = ⌜al0⌝ ^ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0])
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]) ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) |
⊦ finp(σ) → ⌜σ.l⌝ = σ
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), finp(aσ to # al0 + 1) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0])
Used simplifier rules: ⊦ finp(σ to m); (s) Used terms: aσ to # al0 + 1
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), finp(aσ to # al0 + 1) ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ astartf((aσ to # al0 + 1).l[0]) ⊦
Used simplifier rules: ⊦ finp(σ to m); (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ astartf((aσ to # al0 + 1).l[0]) ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m]
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ astartf((aσ to # al0 + 1).l[0]) ⊦ 0 < # al0 + 1 ∧ ¬ # aσ < ⌜# al0 + 1⌝
Used terms: 0, # al0 + 1, aσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m] |
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ astartf((aσ to # al0 + 1).l[0]) ⊦ 0 < # al0 + 1 ∧ ¬ # aσ < ⌜# al0 + 1⌝ |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[0]) ⊦
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) ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[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 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[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 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(as), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[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 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[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 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astartf((aσ to # al0 + 1).l[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
| AIOAut?(AIOAut(astartf, astepf)), ¬ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ asl, al0. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
astartf(as), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used simplifier rules: leqstar-def: ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)); ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ atrace*(AIOAut(startf, stepf))(α) ↔ atrace(AIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ctrace*(CIOAut(startf, stepf))(α) ↔ ctrace(CIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ AIOAut?(AIOAut(startf, stepf)) ↔ (∃ s. startf(s)); (s)
| astartf(as), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
astartf(as), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∃ σ, β. ⌜al⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β) ⊦
Used terms: ⌜al⌝ , cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| astartf(as), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∃ σ, β. ⌜al⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β) ⊦ |
⌜al⌝ = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
al = [], ⌜al⌝ = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
⌜al⌝ = α ^, al ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used formulas: al = []
| al = [], ⌜al⌝ = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
[] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))([]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s)
| [] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))([]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
[] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ σ, β. ¬([] = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦
Used terms: [], astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| [] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ σ, β. ¬([] = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦ |
[] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ σ, β. [] ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| [] = α ^, astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ σ, β. [] ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦ |
⊦ α ^ = [] ↔ (∀ n. ⌜n⌝ < # α → α[n] = τ)
astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ σ, β. [] ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ n. ⌜n⌝ < # α → α[n] = τ ⊦
Used terms: α
| ⊦ α ^ = [] ↔ (∀ n. ⌜n⌝ < # α → α[n] = τ) |
| astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ∀ σ, β. [] ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^), ∀ n. ⌜n⌝ < # α → α[n] = τ ⊦ |
Used simplifier rules: ⊦ [] ^ = []; (s) ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) Used terms: ⌜as '⌝ , []
| ⌜al⌝ = α ^, al ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al⌝ = α ^, al ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), α ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α0 ^ = []), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used terms: α, al
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al⌝ = α ^, al ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), α ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α0 ^ = []), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → cfrag*(CIOAut(startf, stepf))(σ to n + 1, α to n)
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0) ∧ ¬ #(⌜al0⌝ + α0) < ⌜# al0⌝ → cfrag*(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ + α0 to # al0), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used terms: cstartf, cstepf, cσ, ⌜al0⌝ + α0, # al0
| ⊦ cfrag(CIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → cfrag*(CIOAut(startf, stepf))(σ to n + 1, α to n) |
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0) ∧ ¬ #(⌜al0⌝ + α0) < ⌜# al0⌝ → cfrag*(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ + α0 to # al0), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ cfrag*(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + σ to # 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∞ + n∞1 < n∞1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ ⌜al0⌝ ^ = ⌜al⌝ ^) ⊦ |
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → (∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦
Used terms: (cσ to # al0 + 1).l, al0
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → (∃ asl, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al0⌝ ^) ⊦ |
al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦
| al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦ |
⊦ finp(σ) → ⌜σ.l⌝ = σ
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), finp(cσ to # al0 + 1), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦
Used simplifier rules: ⊦ finp(σ to m); (s) Used terms: cσ to # al0 + 1
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), finp(cσ to # al0 + 1), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ) ∧ cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦ |
al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦
Used simplifier rules: ⊦ finp(σ to m); (s)
| al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to # al0 + 1).l[0]) → afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ ⌜al1⌝ ^ = ⌜al⌝ ⊦ |
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(as), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m]
al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦ 0 < # al0 + 1 ∧ ¬ # cσ < ⌜# al0 + 1⌝
Used terms: 0, # al0 + 1, cσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m] |
| al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦ 0 < # al0 + 1 ∧ ¬ # cσ < ⌜# al0 + 1⌝ |
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦
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) ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# cσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → cstepf(cσ[n], (⌜al0⌝ + α0)[n], cσ[n +1]) ⊦
Used terms: ⌜al0⌝ + α0, cσ, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # cσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = al.last, ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]), ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → cstepf(cσ[n], (⌜al0⌝ + α0)[n], cσ[n +1]) ⊦ |
# cσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]), ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → cstepf(cσ[n], (⌜al0⌝ + α0)[n], cσ[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
| # cσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ¬ ⌜# al0⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to # al0 + 1).l[0]), ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → cstepf(cσ[n], (⌜al0⌝ + α0)[n], cσ[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
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(as), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
al0.last = al.last, ⌜al1⌝ ^ = ⌜al⌝ , ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ∀ σ, β. ¬(⌜al⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦
Used terms: ⌜al⌝ , astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| al0.last = al.last, ⌜al1⌝ ^ = ⌜al⌝ , ⌜al0⌝ ^ = ⌜al⌝ , α0 ^ = [], al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(asl[0]), astartf(as), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cstartf(cσ[0]), ∀ σ, β. ¬(⌜al⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦ |
al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(as), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ∀ σ, β. ⌜al⌝ ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| al0.last = al.last, α0 ^ = [], ⌜al0⌝ ^ = ⌜al⌝ , ⌜al1⌝ ^ = ⌜al⌝ , al ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ), astartf(as), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to # al0 + 1, ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al0⌝ + α0), cstartf(cσ[0]), ∀ σ, β. ⌜al⌝ ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦ |
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) Used terms: ⌜asl⌝ , ⌜al1⌝
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.