| ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) |
≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦
| ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ |
⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α))
≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∃ α. ¬(ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)) ⊦
Used terms: astepf, astartf, cstepf, cstartf
| ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)) |
| ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∃ α. ¬(ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)) ⊦ |
ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ atrace*(AIOAut(startf, stepf))(α) ↔ atrace(AIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ctrace*(CIOAut(startf, stepf))(α) ↔ ctrace(CIOAut(startf, stepf))(α) ∧ finp(α); (s)
| ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∃ σ, β. ⌜al⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β) ⊦
Used terms: ⌜al⌝ , cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∃ σ, β. ⌜al⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β) ⊦ |
⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⊦ ¬ # α ^ < ⌜n⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to n = (α to m)^)
⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ # α ^ < ⌜# al⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to # al = (α to m)^) ⊦
Used terms: α, # al
| ⊦ ¬ # α ^ < ⌜n⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to n = (α to m)^) |
| ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ # α ^ < ⌜# al⌝ → (∃ m. ¬ # α < ⌜m⌝ ∧ α ^ to # al = (α to m)^) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
Used simplifier rules: ⊦ x to # x = x; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ¬ n < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ≤wB(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⊦ ≤wB(cioaut, aioaut) ↔ (∃ t, aINV. weakbwsim(cioaut, aioaut, t, aINV))
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∃ t, aINV. weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦
Used terms: AIOAut(astartf, astepf), CIOAut(cstartf, cstepf)
| ⊦ ≤wB(cioaut, aioaut) ↔ (∃ t, aINV. weakbwsim(cioaut, aioaut, t, aINV)) |
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∃ t, aINV. weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cexec(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cexec(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ⊦
Used formulas: cexec(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cexec(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ) ⊦ |
⊦ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)))
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ astartf0(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → astartf0(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as))) ⊦
Used terms: cstartf, cstepf, astartf, astepf, t, astartf0
| ⊦ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as))) |
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ astartf0(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → astartf0(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as))) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ astartf0(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ astartf0(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → (∃ as. t((cσ to m + 1).l.last, as) ∧ astartf0(as)), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
Used terms: (cσ to m + 1).l, (α to m).l
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → (∃ as. t((cσ to m + 1).l.last, as) ∧ astartf0(as)), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ |
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as)
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cexec(CIOAut(cstartf, cstepf))(⌜cσ[0] '⌝ , ⌜[]⌝ ) ∧ cσ[0] '.last = cσ[0] ∧ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜(α to m)^.l⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜(α to m)^.l⌝ , as) ∧ t(cσ[0], as1) ∧ astartf0(as1) ⊦
Used terms: cstartf, cstepf, astartf, astepf, t, astartf0, cσ[0] ', [], cσ[0], (α to m)^.l, cσ[m], as
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as) |
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cexec(CIOAut(cstartf, cstepf))(⌜cσ[0] '⌝ , ⌜[]⌝ ) ∧ cσ[0] '.last = cσ[0] ∧ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜(α to m)^.l⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) ⊦ a '[0] = a; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜[]⌝ = []; (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⊦ finp(σ) → ⌜σ.l⌝ = σ
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), finp(cσ to m + 1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s) ⊦ finp(σ to m); (s) Used terms: cσ to m + 1
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), finp(cσ to m + 1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: ⊦ finp(σ to m); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⊦ finp(σ) → ⌜σ.l⌝ = σ
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), finp(α to m), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s) ⊦ finp(σ to m); (s) Used terms: α to m
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), finp(α to m), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ cfrag(CIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → (cfrag(CIOAut(startf, stepf))(σ to n + 1, α to n) ↔ true); (ss) ⊦ finp(σ to m); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m]
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as), 0 < m + 1 ∧ ¬ # cσ < ⌜m + 1⌝
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, 0 < m + 1, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # cσ < ⌜m + 1⌝ , ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf(cσ[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used terms: 0, m + 1, cσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m] |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as), 0 < m + 1 ∧ ¬ # cσ < ⌜m + 1⌝ |
⌜al⌝ = ⌜nf⌝ ^, ⌜al⌝ = ⌜nf to m⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜nf⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜nf to m⌝ ), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ ⌜m⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as)
Used simplifier rules: ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) stream-inf-forward: ⊦ ¬ finp(σ) → (∃ nf. ⌜nf⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ ¬ ∞ < n∞; (s) ⊦ ¬ finp(σ) → # σ = ∞; (s) ⊦ cfrag(CIOAut(startf, stepf))(σ, α) → (# α < # σ ↔ finp(α)); (ss) lele-trans: ⊦ ¬ n∞1 < n∞ ∧ ¬ n∞2 < n∞1 → ¬ n∞2 < n∞; (forward) from specification nat-inf 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)
| ⌜al⌝ = ⌜nf⌝ ^, ⌜al⌝ = ⌜nf to m⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜nf⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, ⌜nf to m⌝ ), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ ⌜m⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m + 1 ≠ 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , ⌜af⌝ ); (s)
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, 0 < m + 1, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # cσ < ⌜m + 1⌝ , ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cstartf(cσ[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) ∧ astartf0(as) |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t((cσ to m + 1).l.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as)
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) m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t((cσ to m + 1).l.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) |
⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(((cσ to m) + ⌜cσ[m] '⌝ ).l.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as)
Used terms: m, cσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝ |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(((cσ to m) + ⌜cσ[m] '⌝ ).l.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)) ⊦ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]) ∧ t(cσ[m], as) |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (x + a ').last = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ ⌜x⌝ .l = x; (s) finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ finp(σ to m); (s) ⊦ finp(⌜x⌝ ); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cmove(CIOAut(cstartf, cstepf))(cσ[0], ⌜al⌝ , cσ[m]), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cσ[0] = sl[0] ∧ cσ[m] = sl.last ∧ α ^ = ⌜al⌝ ) ⊦
Used terms: cσ[m], ⌜al⌝ , cσ[0], cstepf, cstartf
| ⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cσ[0] = sl[0] ∧ cσ[m] = sl.last ∧ α ^ = ⌜al⌝ ) ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ α0, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α0) ∨ ¬ finp(α0) ∨ cσ[0] ≠ sl[0] ∨ cσ[m] ≠ sl.last ∨ α0 ^ ≠ ⌜al⌝ ⊦
Used simplifier rules: ⊦ cfrag*(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ α0, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α0) ∨ ¬ finp(α0) ∨ cσ[0] ≠ sl[0] ∨ cσ[m] ≠ sl.last ∨ α0 ^ ≠ ⌜al⌝ ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , α to m) ∨ ¬ finp(α to m) ∨ cσ[0] ≠ (cσ to m + 1).l[0] ∨ cσ[m] ≠ (cσ to m + 1).l.last ∨ (α to m)^ ≠ ⌜al⌝ ⊦
Used terms: α to m, (cσ to m + 1).l
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , α to m) ∨ ¬ finp(α to m) ∨ cσ[0] ≠ (cσ to m + 1).l[0] ∨ cσ[m] ≠ (cσ to m + 1).l.last ∨ (α to m)^ ≠ ⌜al⌝ ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , α to m) ∨ cσ[m] ≠ (cσ to m + 1).l.last ⊦
Used simplifier rules: m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n).l[m] = σ[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ finp(σ to m); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , α to m) ∨ cσ[m] ≠ (cσ to m + 1).l.last ⊦ |
⊦ finp(σ) → ⌜σ.l⌝ = σ
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), finp(cσ to m + 1), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ∨ cσ[m] ≠ (cσ to m + 1).l.last ⊦
Used simplifier rules: ⊦ finp(σ to m); (s) Used terms: cσ to m + 1
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cstartf(cσ[0]), finp(cσ to m + 1), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ∨ cσ[m] ≠ (cσ to m + 1).l.last ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cσ[m] ≠ (cσ to m + 1).l.last, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ cfrag(CIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → (cfrag(CIOAut(startf, stepf))(σ to n + 1, α to n) ↔ true); (ss) ⊦ finp(σ to m); (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cσ[m] ≠ (cσ to m + 1).l.last, ⌜m⌝ < # cσ, astartf0(as), cfrag(CIOAut(cstartf, cstepf))((cσ to m) + ⌜cσ[m] '⌝ , α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), t(cσ[m], as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) ⊦ finp(σ to m); (s) finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ ⌜x⌝ .l = x; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] Used terms: m, cσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝ |
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜(α to m)^.l⌝ , as) ∧ t(cσ[0], as1) ∧ astartf0(as1) ⊦ |
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, amove(AIOAut(astartf, astepf))(as1, ⌜al⌝ , as), astartf0(as1), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s)
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, amove(AIOAut(astartf, astepf))(as1, ⌜al⌝ , as), astartf0(as1), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, astartf0(as1), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al⌝ ⊦
Used terms: as, ⌜al⌝ , as1, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, astartf0(as1), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, as) ∧ astartf0(as), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al⌝ ⊦ |
⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
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)
| ⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ σ, β. ¬(⌜al⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦
Used terms: ⌜al⌝ , astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| ⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ σ, β. ¬(⌜al⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β)) ⊦ |
⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ σ, β. ⌜al⌝ ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ σ, β. ⌜al⌝ ≠ β ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, β) ∨ ¬ astartf(σ[0]) ⊦ |
⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ⌜al⌝ ≠ ⌜al0⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∨ ¬ astartf(⌜asl⌝ [0]) ⊦
Used terms: ⌜asl⌝ , ⌜al0⌝
| ⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cstartf(cσ[0]), cstartf((cσ to m + 1)[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ⌜al⌝ ≠ ⌜al0⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∨ ¬ astartf(⌜asl⌝ [0]) ⊦ |
⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al0⌝ ^ = ⌜al⌝ , ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf0(asl[0]), cfrag(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m), cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf((cσ to m + 1)[0]), cstartf(cσ[0]), t(cσ[0], asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜(cσ to m + 1).l⌝ , ⌜(α to m).l⌝ ) ∧ cstartf((cσ to m + 1).l[0]) → t((cσ to m + 1).l.last, asl.last) ∧ astartf0(asl.last), ∀ csl, al0, a, cs0, as0. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ astartf0(as0) → (∃ as. astartf0(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)), ∀ asl, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → astartf0(asl.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ astartf0(as) → astartf(as) ⊦ |
Used terms: cσ[0], asl[0]
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cexec(CIOAut(cstartf, cstepf))(cσ to m + 1, α to m) ⊦ |
⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ cfrag(CIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → (cfrag(CIOAut(startf, stepf))(σ to n + 1, α to n) ↔ true); (ss) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ = α ^, ⌜al⌝ = (α to m)^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]
⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦ 0 < m + 1 ∧ ¬ # cσ < ⌜m + 1⌝
Used terms: 0, m + 1, cσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m] |
| ⌜al⌝ = (α to m)^, ⌜al⌝ = α ^, cfrag(CIOAut(cstartf, cstepf))(cσ, α), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ # α < ⌜m⌝ , ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦ 0 < m + 1 ∧ ¬ # cσ < ⌜m + 1⌝ |
⌜al⌝ = ⌜nf⌝ ^, ⌜al⌝ = ⌜nf to m⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜nf⌝ ), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ ⌜m⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦
Used simplifier rules: ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) stream-inf-forward: ⊦ ¬ finp(σ) → (∃ nf. ⌜nf⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ ¬ ∞ < n∞; (s) ⊦ ¬ finp(σ) → # σ = ∞; (s) ⊦ cfrag(CIOAut(startf, stepf))(σ, α) → (# α < # σ ↔ finp(α)); (ss) lele-trans: ⊦ ¬ n∞1 < n∞ ∧ ¬ n∞2 < n∞1 → ¬ n∞2 < n∞; (forward) from specification nat-inf 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)
| ⌜al⌝ = ⌜nf⌝ ^, ⌜al⌝ = ⌜nf to m⌝ ^, cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜nf⌝ ), cstartf(cσ[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, astartf0), ¬ ⌜m⌝ < # cσ, ¬ atrace(AIOAut(astartf, astepf))(⌜al⌝ ), ¬ cstartf((cσ to m + 1)[0]) ⊦ |
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , ⌜af⌝ ); (s)
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.