| C_≤T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), adet(AIOAut(astartf, astepf)) ⊦ fwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ as, cs. ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) |
⊦ C_≤T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α))
adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ fwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ as, cs. ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as))
Used terms: astepf, astartf, cstepf, cstartf
| ⊦ C_≤T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α)) |
| adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ fwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ as, cs. ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) |
⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0)))
adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (∀ cs. cstartf(cs) → (∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs0) ∧ aafter(AIOAut(astartf, astepf))(β, as0))))
Used terms: λ as, cs. ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as), astepf, astartf, cstepf, cstartf
| ⊦ fwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ r(as0, cs0))) |
| adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (∀ cs. cstartf(cs) → (∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ cstepf(cs, a, cs0) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs0) ∧ aafter(AIOAut(astartf, astepf))(β, as0)))) |
adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (cstartf(cs) → (∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as))) ∧ ( cafter(CIOAut(cstartf, cstepf))(α, cs0) ∧ aafter(AIOAut(astartf, astepf))(α, as) ∧ cstepf(cs0, a, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))))
| adet(AIOAut(astartf, astepf)), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (cstartf(cs) → (∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as))) ∧ ( cafter(CIOAut(cstartf, cstepf))(α, cs0) ∧ aafter(AIOAut(astartf, astepf))(α, as) ∧ cstepf(cs0, a, cs1) → (∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)))) |
adet(AIOAut(astartf, astepf)), cstartf(cs), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| adet(AIOAut(astartf, astepf)), cstartf(cs), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
adet(AIOAut(astartf, astepf)), cstartf(cs), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
| adet(AIOAut(astartf, astepf)), cstartf(cs), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
adet(AIOAut(astartf, astepf)), cstartf(cs), ctrace(CIOAut(cstartf, cstepf))([]) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
Used terms: []
| adet(AIOAut(astartf, astepf)), cstartf(cs), ctrace(CIOAut(cstartf, cstepf))([]) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
adet(AIOAut(astartf, astepf)), cstartf(cs), (∃ σ, β. [] = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
Used terms: [], cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| adet(AIOAut(astartf, astepf)), cstartf(cs), (∃ σ, β. [] = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
adet(AIOAut(astartf, astepf)), cstartf(cs), (∃ σ, β. [] = β ^ ∧ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∧ cstartf(σ[0])) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| adet(AIOAut(astartf, astepf)), cstartf(cs), (∃ σ, β. [] = β ^ ∧ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∧ cstartf(σ[0])) → atrace(AIOAut(astartf, astepf))([]) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
adet(AIOAut(astartf, astepf)), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as), ∃ σ, β. [] = β ^ ∧ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∧ cstartf(σ[0])
adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))([]), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
| adet(AIOAut(astartf, astepf)), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as), ∃ σ, β. [] = β ^ ∧ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∧ cstartf(σ[0]) |
Used simplifier rules: ⊦ [] ^ = []; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) Used terms: ⌜cs '⌝ , []
| adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))([]), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
adet(AIOAut(astartf, astepf)), cstartf(cs), ∃ σ, β. [] = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
Used terms: [], astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| adet(AIOAut(astartf, astepf)), cstartf(cs), ∃ σ, β. [] = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as)
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ ∃ as. (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, as)) ∧ astartf(as) |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, aσ[0])) ∧ astartf(aσ[0])
Used terms: aσ[0]
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, aσ[0])) ∧ astartf(aσ[0]) |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, aσ[0])
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs) ∧ aafter(AIOAut(astartf, astepf))(β, aσ[0]) |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ cafter(CIOAut(cstartf, cstepf))([], cs) ∧ aafter(AIOAut(astartf, astepf))([], aσ[0])
Used terms: []
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs) ⊦ cafter(CIOAut(cstartf, cstepf))([], cs) ∧ aafter(AIOAut(astartf, astepf))([], aσ[0]) |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ¬ cafter(CIOAut(cstartf, cstepf))([], cs) ⊦
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ¬ aafter(AIOAut(astartf, astepf))([], aσ[0]) ⊦
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ¬ cafter(CIOAut(cstartf, cstepf))([], cs) ⊦ |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α, σ. ¬(α ^ = [] ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs = σ.l.last) ⊦
Used terms: cs, [], cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α, σ. ¬(α ^ = [] ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs = σ.l.last) ⊦ |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α0, σ. α0 ^ ≠ [] ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs ≠ σ.l.last ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α0, σ. α0 ^ ≠ [] ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs ≠ σ.l.last ⊦ |
Used simplifier rules: ⊦ [] ^ = []; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ finp([]); (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) Used terms: [], ⌜cs '⌝
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ¬ aafter(AIOAut(astartf, astepf))([], aσ[0]) ⊦ |
⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α, σ. ¬(α ^ = [] ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ aσ[0] = σ.l.last) ⊦
Used terms: aσ[0], [], astepf, astartf
| ⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α, σ. ¬(α ^ = [] ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ aσ[0] = σ.l.last) ⊦ |
[] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α0, σ. α0 ^ ≠ [] ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α0) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α0) ∨ aσ[0] ≠ σ.l.last ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| [] = α ^, adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cstartf(cs), ∀ α0, σ. α0 ^ ≠ [] ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α0) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α0) ∨ aσ[0] ≠ σ.l.last ⊦ |
Used simplifier rules: ⊦ [] ^ = []; (s) ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ a '[0] = a; (s) ⊦ finp([]); (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ a '.last = a; (s) Used terms: [], ⌜aσ[0] '⌝
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a = τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used formulas: a = τ
| a = τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s)
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(as, [], as) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as))
Used terms: as
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(as, [], as) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as)) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as)
Used simplifier rules: ⊦ amove(AIOAut(startf, stepf))(s, [], s); (s)
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ cafter(CIOAut(cstartf, cstepf))(α, cs1) ∧ aafter(AIOAut(astartf, astepf))(α, as)
Used terms: α
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ cafter(CIOAut(cstartf, cstepf))(α, cs1) ∧ aafter(AIOAut(astartf, astepf))(α, as) |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ¬ cafter(CIOAut(cstartf, cstepf))(α, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ¬ cafter(CIOAut(cstartf, cstepf))(α, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α0, σ. ¬(α0 ^ = α ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α0) ∧ cs1 = σ.l.last) ⊦
Used terms: cs1, α, cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α0, σ. ¬(α0 ^ = α ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α0) ∧ cs1 = σ.l.last) ⊦ |
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α0, σ. α0 ^ ≠ α ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α0, σ. α0 ^ ≠ α ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs1 ≠ σ.l.last ⊦ |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cstepf(cs0, τ, cs1), ∀ α0, σ. α0 ^ ≠ α ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs1 ≠ σ.l.last, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∃ α0, σ. α0 ^ = α ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α0) ∧ cs0 = σ.l.last ⊦
Used terms: cs0, α, cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cstepf(cs0, τ, cs1), ∀ α0, σ. α0 ^ ≠ α ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α0) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α0) ∨ cs1 ≠ σ.l.last, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∃ α0, σ. α0 ^ = α ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α0) ∧ cs0 = σ.l.last ⊦ |
aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, σ. α1 ^ ≠ ⌜al⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α1) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α1) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, σ. α1 ^ ≠ ⌜al⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α1) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α1) ∨ cs1 ≠ σ.l.last ⊦ |
aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ⌜al + τ⌝ ^ ≠ ⌜al⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al + τ⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ∨ ¬ finp(⌜al + τ⌝ ) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦
Used terms: ⌜al + τ⌝ , cσ + ⌜cs1 '⌝
| aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ⌜al + τ⌝ ^ ≠ ⌜al⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al + τ⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ∨ ¬ finp(⌜al + τ⌝ ) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦ |
aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ σ + [] = σ; (s) ⊦ ⌜τ '⌝ ^ = []; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦ |
⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m]
⌜0⌝ < # cσ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ ¬ cstartf(cσ[0]) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦
Used simplifier rules: ⊦ ⌜0⌝ < # σ ↔ σ ≠ []; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp([]); (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] ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, ⌜cs1 '⌝ , cσ
| ⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m] |
| ⌜0⌝ < # cσ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ ¬ cstartf(cσ[0]) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦ |
cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦
Used simplifier rules: ⊦ ⌜0⌝ < # σ ↔ σ ≠ []; (s)
| cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ) ∨ cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last ⊦ |
cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last, cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
| cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# cσ = # ⌜al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf(cσ[n], ⌜al⌝ [n], cσ[n +1]) ⊦
Used terms: ⌜al⌝ , cσ, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # cσ = # ⌜al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf(cσ[n], ⌜al⌝ [n], cσ[n +1]) ⊦ |
# cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]) ⊦
Used simplifier rules: ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜τ '⌝ ), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), #(cσ + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜τ '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜τ '⌝ ) → cstepf((cσ + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜τ '⌝ )[n], (cσ + ⌜cs1 '⌝ )[n +1]))) ⊦
Used terms: ⌜al⌝ + ⌜τ '⌝ , cσ + ⌜cs1 '⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), #(cσ + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜τ '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜τ '⌝ ) → cstepf((cσ + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜τ '⌝ )[n], (cσ + ⌜cs1 '⌝ )[n +1]))) ⊦ |
# cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), n ≤ # al, ¬ cstepf((cσ + ⌜cs1 '⌝ )[n], (al + τ ')[n], (cσ + ⌜cs1 '⌝ )[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ n < m → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ n∞1 = ⌜m - n⌝ + n∞2); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # cσ = ⌜# al⌝ + ⌜1⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), n ≤ # al, ¬ cstepf((cσ + ⌜cs1 '⌝ )[n], (al + τ ')[n], (cσ + ⌜cs1 '⌝ )[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]) ⊦ |
# cσ = ⌜# al⌝ + ⌜1⌝ , cσ = ⌜csl0⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), n ≤ # al, ¬ cstepf((cσ + ⌜cs1 '⌝ )[n], (al + τ ')[n], (cσ + ⌜cs1 '⌝ )[n + 1]), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜m⌝ + n∞ = ∞ ↔ n∞ = ∞; (s) ⊦ ⌜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
| # cσ = ⌜# al⌝ + ⌜1⌝ , cσ = ⌜csl0⌝ , cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), n ≤ # al, ¬ cstepf((cσ + ⌜cs1 '⌝ )[n], (al + τ ')[n], (cσ + ⌜cs1 '⌝ )[n + 1]), ∀ n. n < # al → cstepf(cσ[n], al[n], cσ[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al + 1 = # csl0, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(hd(csl0)), cstepf(csl0.last, τ, cs1), n ≤ # al, ¬ cstepf((csl0 + cs1 ')[n], (al + τ ')[n], (csl0 + cs1 ')[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # al → cstepf(csl0[n0], al[n0], csl0[n0 + 1]) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # al + 1 = # csl0, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(hd(csl0)), cstepf(csl0.last, τ, cs1), n ≤ # al, ¬ cstepf((csl0 + cs1 ')[n], (al + τ ')[n], (csl0 + cs1 ')[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # al → cstepf(csl0[n0], al[n0], csl0[n0 + 1]) ⊦ |
# al + 1 = # csl0, csl0 = cs + csl, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl0.last, τ, cs1), n ≤ # al, ¬ cstepf((csl0 + cs1 ')[n], (al + τ ')[n], (csl0 + cs1 ')[n + 1]), ∀ n0. n0 < # al → cstepf(csl0[n0], al[n0], csl0[n0 + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl0, cs, y
| # al + 1 = # csl0, csl0 = cs + csl, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl0.last, τ, cs1), n ≤ # al, ¬ cstepf((csl0 + cs1 ')[n], (al + τ ')[n], (csl0 + cs1 ')[n + 1]), ∀ n0. n0 < # al → cstepf(csl0[n0], al[n0], csl0[n0 + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf(((cs ' + csl) + cs1 ')[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ a + x = a ' + x; (s) ⊦ a ' + x ≠ []; (s) ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf(((cs ' + csl) + cs1 ')[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# al = # csl, n < #(cs ' + csl), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ n → (n < m ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n, cs1 ', cs ' + csl
| ⊦ n < # x → (x + y)[n] = x[n] |
| # al = # csl, n < #(cs ' + csl), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. n0 < # csl → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦ |
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used terms: n
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ n < # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ m < n → m ≤ n; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ x ≠ [] → (a ' + x).last = x.last; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: n, cs1 ', csl
| ⊦ n < # x → (x + y)[n] = x[n] |
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), n ≤ # csl, ¬ n < # csl, ¬ cstepf((cs ' + csl)[n], (al + τ ')[n], (csl + cs1 ')[n]), n < # csl → cstepf((cs ' + csl)[n], al[n], csl[n]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ ¬ n < n; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m ≤ m; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # al = # csl, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ x ≠ [] → (a ' + x).last = x.last
# al = # csl, csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ a '.last = a; (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ # [] = 0; (s) ⊦ a '[0] = a; (s) Used terms: csl, cs
| ⊦ x ≠ [] → (a ' + x).last = x.last |
| # al = # csl, csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
# al = # csl, csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
| # al = # csl, csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, τ, cs1), ¬ cstepf((cs ' + csl)[# csl], τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
Used simplifier rules: ⊦ x + a ' ≠ []; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ (x + a ')[# x] = a; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: csl, cs0, y
| cs1 ≠ (cσ + ⌜cs1 '⌝ ).l.last, cσ ≠ [], aafter(AIOAut(astartf, astepf))(⌜al⌝ ^, as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, τ, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ + σ = ⌜nf⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ [] ≠ ⌜nf⌝ ; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s) ⊦ finp(⌜x⌝ ); (s) finp(σ) ⊦ (⌜x⌝ + σ).l = x + σ.l; (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream]
| a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: α + ⌜a '⌝
| a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
α = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
α = ⌜af0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;;
| α = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ σ, β. ¬(⌜al0⌝ + ⌜a '⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al0⌝ + ⌜a '⌝ , cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ σ, β. ¬(⌜al0⌝ + ⌜a '⌝ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstepf(cs0, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]), ∃ α, σ. α ^ = ⌜al0⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs0 = σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: cs0, ⌜al0⌝ , cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstepf(cs0, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]), ∃ α, σ. α ^ = ⌜al0⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs0 = σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ σ, β. ⌜al0⌝ + ⌜a '⌝ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ⌜al0⌝ + ⌜a '⌝ ≠ ⌜al + a⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al + a⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: cσ + ⌜cs1 '⌝ , ⌜al + a⌝
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ⌜al0⌝ + ⌜a '⌝ ≠ ⌜al + a⌝ ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al + a⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , cσ = ⌜csl0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| ⌜al⌝ ^ = ⌜al0⌝ , cσ = ⌜csl0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(cσ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((cσ + ⌜cs1 '⌝ )[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((csl0 + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ .l = x; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((csl0 + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ n < # x → (x + y)[n] = x[n]
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # csl0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf(csl0[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, cs1 ', csl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # csl0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf(csl0[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(hd(csl0)), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(hd(csl0)), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , csl0 = cs + csl, a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(cs), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl0, cs, y
| ⌜al⌝ ^ = ⌜al0⌝ , csl0 = cs + csl, a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(cs), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), #((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → cstepf(((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], ((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n +1]))) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al⌝ + ⌜a '⌝ , (⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), #((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → cstepf(((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], ((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n +1]))) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ + ⌜x1⌝ )[m] = (x + x0 + x1)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
#(⌜cs '⌝ + ⌜csl⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf((⌜cs '⌝ + ⌜csl⌝ )[n], ⌜al⌝ [n], (⌜cs '⌝ + ⌜csl⌝ )[n +1]), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al⌝ , ⌜cs '⌝ + ⌜csl⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| #(⌜cs '⌝ + ⌜csl⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf((⌜cs '⌝ + ⌜csl⌝ )[n], ⌜al⌝ [n], (⌜cs '⌝ + ⌜csl⌝ )[n +1]), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # al → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # al → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: n
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n < # cs ', aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf(cs '[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: n, csl + cs1 ', cs '
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n - # cs '], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) Used terms: cs ', csl, n
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n - # cs '], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n - 1], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n - 1], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , n = n0 + 1, a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n0], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, m
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , n = n0 + 1, a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf(csl[n0], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ n0 + 1 < # al, ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ n < # x → (x + a ')[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] Used terms: al, a ', n0 + 1
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ n0 + 1 < # al, ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = n0 + 1, # al = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + n < m + n0 ↔ n < n0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m + 1 ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # csl = n0 + 1, # al = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ y ≠ [] → (x + y).last = y.last
# al = n0 + 1, # csl = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: cs ', csl
| ⊦ y ≠ [] → (x + y).last = y.last |
| # al = n0 + 1, # csl = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(csl.last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
Used simplifier rules: ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) ⊦ m + n = m + n0 ↔ n = n0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ x + a ' ≠ []; (s) ⊦ n = # x → (x + a ')[n] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: csl, cs0, y
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n < # cs ', aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf(cs '[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, (al + a ')[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (a ' + x)[0] = a; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ a '[0] = a; (s) ⊦ 0 ≤ m; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, (al + a ')[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, al[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a '[0] = a; (s) ⊦ x + [] = x; (s) ⊦ a '.last = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a '[0] = a; (s) Used terms: 0, a ', al
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, al[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, hd(al), csl[0]), ¬ cstepf(cs, hd(al), (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, hd(al), csl[0]), ¬ cstepf(cs, hd(al), (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , al = a0 + al1, a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(cs, a0, csl[0]), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: al, a0, y
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , al = a0 + al1, a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf(cs, a0, csl[0]), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# csl = # al1 + 1, ⌜a0 '⌝ ^ + ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, a0, csl[0]), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ' + x ≠ []; (s) ⊦ a + x = a ' + x; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # csl = # al1 + 1, ⌜a0 '⌝ ^ + ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, a0, csl[0]), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: 0, cs1 ', csl
| ⊦ n < # x → (x + y)[n] = x[n] |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)), ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1)
Used formulas: ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as1))
Used terms: as1
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as1)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as1)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1), ∃ σ, β. ⌜al0⌝ + ⌜a '⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦
Used terms: ⌜al0⌝ + ⌜a '⌝ , astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1), ∃ σ, β. ⌜al0⌝ + ⌜a '⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ |
⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(α ^, as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(α ^, as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(α ^, as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1), α ^ = ⌜al0 + a⌝ ∧ al0 + a ≠ [] → (∃ al1, α0. α = ⌜al1⌝ + α0 ∧ al1 ≠ [] ∧ ⌜al1⌝ ^ = ⌜al0 + a⌝ ∧ al1.last = (al0 + a).last ∧ α0 ^ = []) ⊦
Used terms: α, al0 + a
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(α ^, as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1), α ^ = ⌜al0 + a⌝ ∧ al0 + a ≠ [] → (∃ al1, α0. α = ⌜al1⌝ + α0 ∧ al1 ≠ [] ∧ ⌜al1⌝ ^ = ⌜al0 + a⌝ ∧ al1.last = (al0 + a).last ∧ α0 ^ = []) ⊦ |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as1) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ (x + a ').last = a; (s) ⊦ x + a = x + a '; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as1) ⊦ |
⌜al0⌝ + ⌜a '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1 = al + a ', a ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: al1, a, y
| ⌜al0⌝ + ⌜a '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1 = al + a ', a ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⊦ finp(σ) ∧ # σ = # σ1 → (σ + σ0 = σ1 + σ2 ↔ σ = σ1 ∧ σ0 = σ2)
⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ finp(⌜al0⌝ ) ∧ # ⌜al0⌝ = # ⌜al⌝ ^
# ⌜al0⌝ = # ⌜al⌝ ^, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜a '⌝ = ⌜a '⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(⌜al0⌝ ), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used terms: ⌜a '⌝ , ⌜al⌝ ^, ⌜a '⌝ , ⌜al0⌝
| ⊦ finp(σ) ∧ # σ = # σ1 → (σ + σ0 = σ1 + σ2 ↔ σ = σ1 ∧ σ0 = σ2) |
| ⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ finp(⌜al0⌝ ) ∧ # ⌜al0⌝ = # ⌜al⌝ ^ |
⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, ⌜# al0⌝ ≠ # ⌜al⌝ ^, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used simplifier rules: ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ finp(⌜x⌝ ); (s)
| ⌜al0⌝ + ⌜a '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , α0 ^ = [], a ≠ τ, ⌜# al0⌝ ≠ # ⌜al⌝ ^, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])
Used simplifier rules: ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ n∞ + ⌜0⌝ = 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 Used terms: ⌜al⌝ ^ + ⌜a '⌝ , ⌜al0⌝ + ⌜a '⌝
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| # ⌜al0⌝ = # ⌜al⌝ ^, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜a '⌝ = ⌜a '⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al⌝ ^ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(⌜al0⌝ ), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦
Used simplifier rules: ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ finp(⌜x⌝ ); (s)
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as1) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦
Used terms: as1, ⌜a '⌝ , as, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as = sl[0] ∧ as1 = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n)
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0) ∧ ¬ #((⌜al⌝ + ⌜a '⌝ ) + α0) < ⌜# al + 1⌝ → afrag*(AIOAut(astartf, astepf))(aσ to (# al + 1) + 1, (⌜al⌝ + ⌜a '⌝ ) + α0 to # al + 1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used terms: astartf, astepf, aσ, (⌜al⌝ + ⌜a '⌝ ) + α0, # al + 1
| ⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n) |
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0) ∧ ¬ #((⌜al⌝ + ⌜a '⌝ ) + α0) < ⌜# al + 1⌝ → afrag*(AIOAut(astartf, astepf))(aσ to (# al + 1) + 1, (⌜al⌝ + ⌜a '⌝ ) + α0 to # al + 1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜a '⌝ + σ to 1 = ⌜a '⌝ ; (s) ⊦ ⌜x⌝ + σ to m + # x = ⌜x⌝ + (σ to 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∞ + n∞1 < n∞1; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ⌜n⌝ < # α → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n) ∧ afrag(AIOAut(startf, stepf))(σ from n, α from n)
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ) ∧ ⌜# al⌝ < #(⌜al⌝ + ⌜a '⌝ ) → afrag*(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ + ⌜a '⌝ to # al) ∧ afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜al⌝ + ⌜a '⌝ from # al), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used terms: astartf, astepf, aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ , # al
| ⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ⌜n⌝ < # α → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n) ∧ afrag(AIOAut(startf, stepf))(σ from n, α from n) |
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ) ∧ ⌜# al⌝ < #(⌜al⌝ + ⌜a '⌝ ) → afrag*(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ + ⌜a '⌝ to # al) ∧ afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜al⌝ + ⌜a '⌝ from # al), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + σ from # x = σ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) ⊦ ⌜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; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ as ≠ sl[0] ∨ as1 ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al).l⌝ , ⌜a '⌝ ) ∨ ¬ finp(⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ∨ ⌜a '⌝ ^ ≠ ⌜a '⌝ ⊦
Used terms: ⌜a '⌝ , ((aσ to 2 + # al) from # al).l
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al).l⌝ , ⌜a '⌝ ) ∨ ¬ finp(⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ∨ ⌜a '⌝ ^ ≠ ⌜a '⌝ ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al).l⌝ , ⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ⊦
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ finp(⌜x⌝ ); (s)
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al).l⌝ , ⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ⊦ |
⊦ finp(σ) → ⌜σ.l⌝ = σ
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp((aσ to 2 + # al) from # al), ¬ afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ⊦
Used simplifier rules: stream-inf-forward: ⊦ ¬ finp(σ) → (∃ nf. ⌜nf⌝ = σ); (forward) from specification stream-basic[traceA-IOstatestream] ⊦ ¬ afrag(AIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s) Used terms: (aσ to 2 + # al) from # al
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp((aσ to 2 + # al) from # al), ¬ afrag(AIOAut(astartf, astepf))((aσ to 2 + # al) from # al, ⌜a '⌝ ) ∨ as ≠ ((aσ to 2 + # al) from # al).l[0] ∨ as1 ≠ ((aσ to 2 + # al) from # al).l.last ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
Used simplifier rules: ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[traceA-IOstatestream]
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
⊦ adet(AIOAut(startf, stepf)) → (∀ β, s1, s2. aafter(AIOAut(startf, stepf))(β, s1) ∧ aafter(AIOAut(startf, stepf))(β, s2) → s1 = s2)
α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), adet(AIOAut(astartf, astepf)) → (∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
Used terms: astartf, astepf
| ⊦ adet(AIOAut(startf, stepf)) → (∀ β, s1, s2. aafter(AIOAut(startf, stepf))(β, s1) ∧ aafter(AIOAut(startf, stepf))(β, s2) → s1 = s2) |
| α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), adet(AIOAut(astartf, astepf)) → (∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
Used terms: ⌜al0⌝ , as, asl[0]
| α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
| α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ, (⌜al⌝ + ⌜a '⌝ ) + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #((⌜al⌝ + ⌜a '⌝ ) + α0) + ⌜1⌝ , α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ⌜n⌝ < #((⌜al⌝ + ⌜a '⌝ ) + α0) → astepf(aσ[n], ((⌜al⌝ + ⌜a '⌝ ) + α0)[n], aσ[n +1]), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
Used terms: (⌜al⌝ + ⌜a '⌝ ) + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #((⌜al⌝ + ⌜a '⌝ ) + α0) + ⌜1⌝ , α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ⌜n⌝ < #((⌜al⌝ + ⌜a '⌝ ) + α0) → astepf(aσ[n], ((⌜al⌝ + ⌜a '⌝ ) + α0)[n], aσ[n +1]), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ¬ ⌜# al⌝ + # α0 < ⌜n⌝ → astepf(aσ[n], ((⌜al⌝ + ⌜a '⌝ ) + α0)[n], aσ[n + 1]), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
Used simplifier rules: ⊦ m +1 = m + 1; (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∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ¬ ⌜# al⌝ + # α0 < ⌜n⌝ → astepf(aσ[n], ((⌜al⌝ + ⌜a '⌝ ) + α0)[n], aσ[n + 1]), as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]) → as = asl[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], as = asl[0], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ α, σ. ¬(α ^ = ⌜al0⌝ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ asl[0] = σ.l.last) ⊦
Used terms: asl[0], ⌜al0⌝ , astepf, astartf
| ⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ α, σ. ¬(α ^ = ⌜al0⌝ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ asl[0] = σ.l.last) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ α, σ. α ^ ≠ ⌜al0⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ asl[0] ≠ σ.l.last ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ α, σ. α ^ ≠ ⌜al0⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ asl[0] ≠ σ.l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ⌜al⌝ ^ ≠ ⌜al0⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ) ∨ ¬ astartf((aσ to 2 + # al to # al + 1)[0]) ∨ ¬ finp(⌜al⌝ ) ∨ asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last ⊦
Used terms: ⌜al⌝ , aσ to 2 + # al to # al + 1
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ⌜al⌝ ^ ≠ ⌜al0⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ) ∨ ¬ astartf((aσ to 2 + # al to # al + 1)[0]) ∨ ¬ finp(⌜al⌝ ) ∨ asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ¬ astartf((aσ to 2 + # al to # al + 1)[0]) ∨ asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ¬ astartf((aσ to 2 + # al to # al + 1)[0]) ∨ asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ 0 < # al + 1 ∧ ¬ #(aσ to 2 + # al) < ⌜# al + 1⌝
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, 0 < # al + 1, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ #(aσ to 2 + # al) < ⌜# al + 1⌝ , ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used terms: 0, # al + 1, aσ to 2 + # al
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m] |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ 0 < # al + 1 ∧ ¬ #(aσ to 2 + # al) < ⌜# al + 1⌝ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
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)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, # aσ < ⌜2 + # al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + m0 ≤ m ↔ m0 = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: 2 + # al, aσ
| ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, # aσ < ⌜2 + # al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ ⌜# al⌝ < #(aσ to 2 + # al), ¬ astartf((aσ to 2 + # al to # al + 1)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
Used simplifier rules: ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, 0 < # al + 1, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ #(aσ to 2 + # al) < ⌜# al + 1⌝ , ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
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)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ 0 < 2 + # al ∧ ¬ # aσ < ⌜2 + # al⌝
Used terms: 0, 2 + # al, aσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m] |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ 0 < 2 + # al ∧ ¬ # aσ < ⌜2 + # al⌝ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, ⌜# al⌝ < #(aσ to 2 + # al), # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
Used simplifier rules: ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
¬ # σ < ⌜n⌝ ⊦ m ≤ n → σ to n to m = σ to m
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ ¬ # aσ < ⌜2 + # al⌝ ∧ # al + 1 ≤ 2 + # al
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al + 1 ≤ 2 + # al, ¬ # aσ < ⌜2 + # al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used terms: # al + 1, 2 + # al, aσ
| ¬ # σ < ⌜n⌝ ⊦ m ≤ n → σ to n to m = σ to m |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ ¬ # aσ < ⌜2 + # al⌝ ∧ # al + 1 ≤ 2 + # al |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to 2 + # al to # al + 1).l.last, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
Used simplifier rules: ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al + 1 ≤ 2 + # al, ¬ # aσ < ⌜2 + # al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])
# ⌜asl⌝ = #((aσ to 2 + # al) from # al), # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ⌜n⌝ < # ⌜asl⌝ → ⌜asl⌝ [n] = ((aσ to 2 + # al) from # al)[n] ⊦
Used terms: (aσ to 2 + # al) from # al, ⌜asl⌝
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| # ⌜asl⌝ = #((aσ to 2 + # al) from # al), # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. ⌜n⌝ < # ⌜asl⌝ → ⌜asl⌝ [n] = ((aσ to 2 + # al) from # al)[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜# asl⌝ = #((aσ to 2 + # al) from # al), asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. n < # asl → asl[n] = ((aσ to 2 + # al) from # al)[n] ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜# asl⌝ = #((aσ to 2 + # al) from # al), asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, ∀ n. n < # asl → asl[n] = ((aσ to 2 + # al) from # al)[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜# asl⌝ = #((aσ to 2 + # al) from # al), ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , 0 < # asl → asl[0] = ((aσ to 2 + # al) from # al)[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used terms: 0
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜# asl⌝ = #((aσ to 2 + # al) from # al), ⌜al0⌝ = ⌜al⌝ ^, asl[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , 0 < # asl → asl[0] = ((aσ to 2 + # al) from # al)[0], ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], hd(asl) = ((aσ to 2 + # al) from # al)[0], ⌜# asl⌝ = #((aσ to 2 + # al) from # al), ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, asl ≠ [], hd(asl) ≠ (aσ to # al + 1).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) ⊦ ⌜[]⌝ = []; (s) ⊦ # σ = ⌜0⌝ ↔ σ = []; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], hd(asl) = ((aσ to 2 + # al) from # al)[0], ⌜# asl⌝ = #((aσ to 2 + # al) from # al), ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, asl ≠ [], hd(asl) ≠ (aσ to # al + 1).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], as0 = ((aσ to 2 + # al) from # al)[0], asl = as0 + asl0, ⌜al0⌝ = ⌜al⌝ ^, ⌜# asl⌝ = #((aσ to 2 + # al) from # al), a ≠ τ, as0 ≠ (aσ to # al + 1).l.last, asl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl, as0, y
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], as0 = ((aσ to 2 + # al) from # al)[0], asl = as0 + asl0, ⌜al0⌝ = ⌜al⌝ ^, ⌜# asl⌝ = #((aσ to 2 + # al) from # al), a ≠ τ, as0 ≠ (aσ to # al + 1).l.last, asl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s) ⊦ a ' + x ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ (aσ to # al + 1).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ ((aσ to # al) + ⌜aσ[# al] '⌝ ).l.last, a ≠ τ, ⌜# al⌝ < # aσ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))((aσ to # al) + ⌜aσ[# al] '⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: lele-trans: ⊦ ¬ n∞1 < n∞ ∧ ¬ n∞2 < n∞1 → ¬ n∞2 < n∞; (forward) from specification nat-inf ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + m0 ≤ m ↔ m0 = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: # al, aσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝ |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ ((aσ to # al) + ⌜aσ[# al] '⌝ ).l.last, a ≠ τ, ⌜# al⌝ < # aσ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))((aσ to # al) + ⌜aσ[# al] '⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ aσ[# al], a ≠ τ, ⌜# al⌝ < # aσ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))((aσ to # al) + ⌜aσ[# al] '⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜x⌝ .l = x; (s) finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ finp(σ to m); (s) ⊦ finp(⌜x⌝ ); (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[0] ≠ aσ[# al], a ≠ τ, ⌜# al⌝ < # aσ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))((aσ to # al) + ⌜aσ[# al] '⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜((aσ to 2 + # al) from # al)[0] '⌝ + ⌜asl0⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # aσ < ⌜2⌝ + ⌜# al⌝ , ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
⊦ ⌜n⌝ + ⌜m⌝ < # σ → (σ from n)[m] = σ[n + m]
Used simplifier rules: ⊦ n + 0 = n; (s) ⊦ m < m + n ↔ n ≠ 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 m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ ; (s) ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + m0 ≤ m ↔ m0 = 0; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: 0, # al, aσ to 2 + # al
| ⊦ ⌜n⌝ + ⌜m⌝ < # σ → (σ from n)[m] = σ[n + m] |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], as = asl[0], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2, as ≠ asl[0] ∨ as1 ≠ asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as1 ≠ asl.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as1 ≠ asl.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ β, s1, s2. aafter(AIOAut(astartf, astepf))(β, s1) ∧ aafter(AIOAut(astartf, astepf))(β, s2) → s1 = s2 ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, as1 ≠ asl.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , asl.last) → as1 = asl.last ⊦
Used terms: ⌜al0⌝ + ⌜a '⌝ , as1, asl.last
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, as1 ≠ asl.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , asl.last) → as1 = asl.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , asl.last) ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , asl.last) ⊦ |
⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. ¬(α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ asl.last = σ.l.last) ⊦
Used terms: asl.last, ⌜al0⌝ + ⌜a '⌝ , astepf, astartf
| ⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. ¬(α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ asl.last = σ.l.last) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ asl.last ≠ σ.l.last ⊦
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ asl.last ≠ σ.l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ⌜al + a⌝ ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al + a⌝ ) ∨ ¬ astartf((aσ to 2 + # al)[0]) ∨ ¬ finp(⌜al + a⌝ ) ∨ asl.last ≠ (aσ to 2 + # al).l.last ⊦
Used terms: ⌜al + a⌝ , aσ to 2 + # al
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ⌜al + a⌝ ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al + a⌝ ) ∨ ¬ astartf((aσ to 2 + # al)[0]) ∨ ¬ finp(⌜al + a⌝ ) ∨ asl.last ≠ (aσ to 2 + # al).l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ∨ asl.last ≠ (aσ to 2 + # al).l.last ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ∨ asl.last ≠ (aσ to 2 + # al).l.last ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl.last ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦ |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦ 0 < 2 + # al ∧ ¬ # aσ < ⌜2 + # al⌝
Used terms: 0, 2 + # al, aσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m] |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦ 0 < 2 + # al ∧ ¬ # aσ < ⌜2 + # al⌝ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ astartf((aσ to 2 + # al)[0]) ⊦ |
Used simplifier rules: ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜asl⌝ = (aσ to 2 + # al) from # al, ⌜al0⌝ = ⌜al⌝ ^, asl.last ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], asl = asl0 + as ', ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, asl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: asl, as, y
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], asl = asl0 + as ', ⌜al0⌝ = ⌜al⌝ ^, ⌜asl⌝ = (aσ to 2 + # al) from # al, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, asl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , asl[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜asl0⌝ + ⌜as '⌝ = (aσ to 2 + # al) from # al, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜asl0⌝ + ⌜as '⌝ = (aσ to 2 + # al) from # al, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])
#(⌜asl0⌝ + ⌜as '⌝ ) = #((aσ to 2 + # al) from # al), # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ⌜n⌝ < #(⌜asl0⌝ + ⌜as '⌝ ) → (⌜asl0⌝ + ⌜as '⌝ )[n] = ((aσ to 2 + # al) from # al)[n] ⊦
Used terms: (aσ to 2 + # al) from # al, ⌜asl0⌝ + ⌜as '⌝
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| #(⌜asl0⌝ + ⌜as '⌝ ) = #((aσ to 2 + # al) from # al), # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ⌜n⌝ < #(⌜asl0⌝ + ⌜as '⌝ ) → (⌜asl0⌝ + ⌜as '⌝ )[n] = ((aσ to 2 + # al) from # al)[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl0 < n → (asl0 + as ')[n] = ((aσ to 2 + # al) from # al)[n] ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl0 < n → (asl0 + as ')[n] = ((aσ to 2 + # al) from # al)[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # asl0 < # asl0 → (asl0 + as ')[# asl0] = ((aσ to 2 + # al) from # al)[# asl0] ⊦
Used terms: # asl0
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, a ≠ τ, as ≠ (aσ to 2 + # al).l.last, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ # asl0 < # asl0 → (asl0 + as ')[# asl0] = ((aσ to 2 + # al) from # al)[# asl0] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ')[# x] = a; (s) ⊦ ¬ n < n; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = [], α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = asl + as ', α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (aσ to 2 + # al).l ≠ [], ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: (aσ to 2 + # al).l, as, y
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = [], α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ (aσ to 2 + # al).l.last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = [], α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ [].last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = [], α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ [].last, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
Used simplifier rules: astatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ nf to n = [] ↔ n = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜x⌝ to n = ⌜x to n⌝ ; (s) ⊦ ⌜x⌝ from n = ⌜x from n⌝ ; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ # [] = 0; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = asl + as ', α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (aσ to 2 + # al).l ≠ [], ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = asl + as ', α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) ⊦ x + a ' ≠ []; (s) in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[traceA-IOstatestream]
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), (aσ to 2 + # al).l = asl + as ', α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜(aσ to 2 + # al).l⌝ = ⌜asl + as '⌝ , ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used terms: asl + as ', (aσ to 2 + # al).l
| ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0 |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, ⌜(aσ to 2 + # al).l⌝ = ⌜asl + as '⌝ , ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
⊦ finp(σ) → ⌜σ.l⌝ = σ
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl + as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(aσ to 2 + # al) ⊦
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ finp(σ to m); (s) Used terms: aσ to 2 + # al
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #((aσ to 2 + # al) from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl + as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((aσ to 2 + # al) from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((aσ to 2 + # al) from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((aσ to 2 + # al) from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(aσ to 2 + # al, ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(aσ to 2 + # al) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #(⌜asl⌝ + ⌜as '⌝ from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: ⊦ finp(σ to m); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #(⌜asl⌝ + ⌜as '⌝ from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
⊦ ⌜n⌝ < # σ ∧ finp(σ) → #(σ from n) = ⌜(# σ).n - n⌝
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #(⌜asl⌝ + ⌜as '⌝ from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ⌜# al⌝ < #(⌜asl⌝ + ⌜as '⌝ ) ∧ finp(⌜asl⌝ + ⌜as '⌝ )
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = ⌜(#(⌜asl⌝ + ⌜as '⌝ )).n - # al⌝ , α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, ⌜# al⌝ < #(⌜asl⌝ + ⌜as '⌝ ), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(⌜asl⌝ + ⌜as '⌝ ) ⊦
Used terms: # al, ⌜asl⌝ + ⌜as '⌝
| ⊦ ⌜n⌝ < # σ ∧ finp(σ) → #(σ from n) = ⌜(# σ).n - n⌝ |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = #(⌜asl⌝ + ⌜as '⌝ from # al), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ⌜# al⌝ < #(⌜asl⌝ + ⌜as '⌝ ) ∧ finp(⌜asl⌝ + ⌜as '⌝ ) |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from (# al - # asl)), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from (# al - # asl))[# asl0] ≠ as, a ≠ τ, al ≠ [], # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from (# al - # asl))[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from (# al - # asl))[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜x⌝ from n = ⌜x from n⌝ ; (s) ⊦ # x < m → ⌜x⌝ + σ from m = σ from (m - # x); (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from (# al - # asl)), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from (# al - # asl))[# asl0] ≠ as, a ≠ τ, al ≠ [], # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from (# al - # asl))[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from (# al - # asl))[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, # asl0 + 1 = #(as ' from n0), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # asl ≤ # al ⊦
Used simplifier rules: ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ n < m → m - n ≠ 0; (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) n ≤ m ⊦ (m - n) + n0 = n1 ↔ m + n0 = n + n1; (s) ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m < n → m ≤ n; (s) n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # al, # asl, n0
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, # asl0 + 1 = #(as ' from n0), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # asl ≤ # al ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, # asl0 + 1 = #(as ' from n0), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < m + n ↔ n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m < n → m ≤ n; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, # asl0 + 1 = #(as ' from n0), α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ |
⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])
#(aσ to 2 + # al) = #(⌜asl⌝ + ⌜as '⌝ ), # al = n0 + # asl, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ⌜n⌝ < #(aσ to 2 + # al) → (aσ to 2 + # al)[n] = (⌜asl⌝ + ⌜as '⌝ )[n] ⊦
Used terms: ⌜asl⌝ + ⌜as '⌝ , aσ to 2 + # al
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| #(aσ to 2 + # al) = #(⌜asl⌝ + ⌜as '⌝ ), # al = n0 + # asl, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ⌜n⌝ < #(aσ to 2 + # al) → (aσ to 2 + # al)[n] = (⌜asl⌝ + ⌜as '⌝ )[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, #(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ n∞ = ⌜m⌝ + ⌜n0⌝ → (⌜n⌝ < n∞ ↔ n < m + n0); (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, #(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦ |
¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝
#(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # al = n0 + # asl, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # aσ < ⌜2 + # al⌝ , # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦
Used simplifier rules: ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ n < m → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ n∞1 = ⌜m - n⌝ + n∞2); (s) ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ n0 = n1 + n2 → (n2 = n0 + 1 ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: 2 + # al, aσ
| ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ |
| #(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # al = n0 + # asl, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # aσ < ⌜2 + # al⌝ , # asl < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, #(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # al = n0 + # asl, #(aσ to 2 + # al) = ⌜# asl⌝ + ⌜1⌝ , # asl0 + 1 = #(as ' from n0), α0 ^ = [], ⌜al0⌝ = ⌜al⌝ ^, (as ' from n0)[# asl0] ≠ as, a ≠ τ, al ≠ [], n0 ≠ 0, # asl < # al, # aσ < ⌜2⌝ + ⌜# al⌝ , aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (as ' from n0)[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(as ' from n0)[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ n. ¬ # asl < n → (aσ to 2 + # al)[n] = (asl + as ')[n] ⊦ |
Used simplifier rules: ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, ⌜# asl0⌝ + ⌜1⌝ = ⌜(#(⌜asl⌝ + ⌜as '⌝ )).n - # al⌝ , α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ≠ as, a ≠ τ, ⌜# al⌝ < #(⌜asl⌝ + ⌜as '⌝ ), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + (⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜(⌜asl⌝ + ⌜as '⌝ from # al)[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), finp(⌜asl⌝ + ⌜as '⌝ ) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 = # asl - # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ m ≤ # x → ⌜x⌝ + σ from m = ⌜x from m⌝ + σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ ⌜n⌝ .n = n; (s) n∞ ≠ ∞ ⊦ (⌜m⌝ + n∞).n = m + n∞.n; (s) ⊦ ⌜n⌝ ≠ ∞; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl0 = # asl - # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦ |
# asl0 = n0, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = n0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦
Used simplifier rules: n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # asl, # al, n0
| # asl0 = n0, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = n0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦ |
# asl = # asl0 + # al, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦
| # asl = # asl0 + # al, # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, ((asl from # al) + as ')[# asl0] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + ((asl from # al) + as ')[# asl0] ')[0]), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜((asl from # al) + as ')[# asl0] '⌝ , ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦ |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = # asl0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, as '[# asl0 - #(asl from # al)] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as '[# asl0 - #(asl from # al)] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '[# asl0 - #(asl from # al)] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl, ¬ # asl0 < #(asl from # al) ⊦
Used simplifier rules: ⊦ n < # x → (x + a ')[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m ≤ n → (n < m ↔ false); (s) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ # x = 0 ↔ x = []; (s) ⊦ m < n → ¬ n < m; (s) Used terms: # asl0, as ', asl from # al
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = # asl0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, as '[# asl0 - #(asl from # al)] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as '[# asl0 - #(asl from # al)] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '[# asl0 - #(asl from # al)] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl, ¬ # asl0 < #(asl from # al) ⊦ |
# aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = # asl0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, as '[# asl0 - (# asl - # al)] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as '[# asl0 - (# asl - # al)] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '[# asl0 - (# asl - # al)] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦
Used simplifier rules: ⊦ m ≤ m; (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ¬ # x < n ⊦ #(x from n) = # x - n; (s)
| # aσ = ⌜2⌝ + ⌜# al⌝ + # α0, # asl = # asl0 + # al, α0 ^ = [], aσ to 2 + # al = ⌜asl⌝ + ⌜as '⌝ , ⌜al0⌝ = ⌜al⌝ ^, as '[# asl0 - (# asl - # al)] ≠ as, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , (asl0 + as '[# asl0 - (# asl - # al)] ')[0]), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ + ⌜as '[# asl0 - (# asl - # al)] '⌝ , ⌜a '⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ to # al + 1, ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as '⌝ , ⌜al⌝ + ⌜a '⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), # al ≤ # asl ⊦ |
Used simplifier rules: n ≤ m ⊦ (m - n) + n0 = n1 ↔ m + n0 = n + n1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m ≤ n → (n < m ↔ false); (s) n0 ≤ n ⊦ n - n0 ≤ m ↔ n ≤ m + n0; (s) ⊦ m = m + n ↔ n = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m ≤ m; (s) ⊦ a '[0] = a; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ # x = 0 ↔ x = []; (s) ⊦ m < n → ¬ n < m; (s) n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # asl0, # asl - # al, n0
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as1) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ , cs1) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1)
Used terms: ⌜al0⌝ + ⌜a '⌝
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ , cs1) ∧ aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ , cs1) ⊦
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ¬ cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ + ⌜a '⌝ , cs1) ⊦ |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. ¬(α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs1 = σ.l.last) ⊦
Used terms: cs1, ⌜al0⌝ + ⌜a '⌝ , cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. ¬(α ^ = ⌜al0⌝ + ⌜a '⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs1 = σ.l.last) ⊦ |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦ |
⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last, ∃ α, σ. α ^ = ⌜al0⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs0 = σ.l.last ⊦
Used terms: cs0, ⌜al0⌝ , cstepf, cstartf
| ⊦ cafter(CIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ cexec*(CIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstepf(cs0, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last, ∃ α, σ. α ^ = ⌜al0⌝ ∧ cexec*(CIOAut(cstartf, cstepf))(σ, α) ∧ cs0 = σ.l.last ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , cσ = ⌜csl0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: cstatestream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))(⌜sf⌝ , ⌜al⌝ ); (s)
| ⌜al⌝ ^ = ⌜al0⌝ , cσ = ⌜csl0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(cσ, ⌜al⌝ ), cstartf(cσ[0]), cstepf(cσ.l.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ .l = x; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ∀ α, σ. α ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, α) ∨ ¬ cstartf(σ[0]) ∨ ¬ finp(α) ∨ cs1 ≠ σ.l.last ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ⌜al + a⌝ ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0 + cs1⌝ , ⌜al + a⌝ ) ∨ ¬ cstartf(⌜csl0 + cs1⌝ [0]) ∨ ¬ finp(⌜al + a⌝ ) ∨ cs1 ≠ ⌜csl0 + cs1⌝ .l.last ⊦
Used terms: ⌜al + a⌝ , ⌜csl0 + cs1⌝
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ⌜al + a⌝ ^ ≠ ⌜al0⌝ + ⌜a '⌝ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0 + cs1⌝ , ⌜al + a⌝ ) ∨ ¬ cstartf(⌜csl0 + cs1⌝ [0]) ∨ ¬ finp(⌜al + a⌝ ) ∨ cs1 ≠ ⌜csl0 + cs1⌝ .l.last ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((csl0 + cs1 ')[0]) ⊦
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(σ) ⊦ (⌜x⌝ + σ).l = x + σ.l; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf((csl0 + cs1 ')[0]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # csl0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf(csl0[0]) ⊦
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, cs1 ', csl0
| ⊦ n < # x → (x + y)[n] = x[n] |
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # csl0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∨ ¬ cstartf(csl0[0]) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(hd(csl0)), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(hd(csl0)), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , csl0 = cs + csl, a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(cs), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl0, cs, y
| ⌜al⌝ ^ = ⌜al0⌝ , csl0 = cs + csl, a ≠ τ, csl0 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al⌝ ), cstartf(cs), cstepf(csl0.last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cfrag(CIOAut(cstartf, cstepf))((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), #((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → cstepf(((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], ((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n +1]))) ⊦
Used terms: ⌜al⌝ + ⌜a '⌝ , (⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), #((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ ) ≠ #(⌜al⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al⌝ + ⌜a '⌝ ) → cstepf(((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n], (⌜al⌝ + ⌜a '⌝ )[n], ((⌜cs '⌝ + ⌜csl⌝ ) + ⌜cs1 '⌝ )[n +1]))) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ + ⌜x1⌝ )[m] = (x + x0 + x1)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
#(⌜cs '⌝ + ⌜csl⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf((⌜cs '⌝ + ⌜csl⌝ )[n], ⌜al⌝ [n], (⌜cs '⌝ + ⌜csl⌝ )[n +1]), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦
Used terms: ⌜al⌝ , ⌜cs '⌝ + ⌜csl⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| #(⌜cs '⌝ + ⌜csl⌝ ) = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ∀ n. ⌜n⌝ < # ⌜al⌝ → cstepf((⌜cs '⌝ + ⌜csl⌝ )[n], ⌜al⌝ [n], (⌜cs '⌝ + ⌜csl⌝ )[n +1]), # csl ≠ # al ∨ ¬(¬ # al < n → cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n])) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # al → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), ∀ n0. n0 < # al → cstepf((cs ' + csl)[n0], al[n0], csl[n0]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used terms: n
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n < # cs ', aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf(cs '[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used terms: n, csl + cs1 ', cs '
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used simplifier rules: ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((cs ' + csl + cs1 ')[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((csl + cs1 ')[n - # cs '], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) Used terms: cs ', csl + cs1 ', n
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ n < # cs ', ¬ cstepf((csl + cs1 ')[n - # cs '], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((csl + cs1 ')[n - 1], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((csl + cs1 ')[n - 1], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , n = n0 + 1, a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((csl + cs1 ')[n0], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦
Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, m
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , n = n0 + 1, a ≠ τ, n ≠ 0, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf((csl + cs1 ')[n0], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ n0 + 1 < # al, ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦
Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ n < # x → (x + a ')[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] Used terms: al, a ', n0 + 1
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], n0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ n0 + 1 < # al, ¬ cstepf(csl[n0], (al + a ')[n0 + 1], (csl + cs1 ')[n0 + 1]), n0 + 1 < # al → cstepf(csl[n0], al[n0 + 1], csl[n0 + 1]) ⊦ |
# csl = n0 + 1, # al = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + n < m + n0 ↔ n < n0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m + 1 ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ n = # x → (x + a ')[n] = a; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # csl = n0 + 1, # al = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ |
⊦ y ≠ [] → (x + y).last = y.last
# al = n0 + 1, # csl = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf(csl.last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦
Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: cs ', csl
| ⊦ y ≠ [] → (x + y).last = y.last |
| # al = n0 + 1, # csl = n0 + 1, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], csl ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf(csl.last, a, cs1), ¬ cstepf(csl[n0], a, cs1) ⊦ |
Used simplifier rules: ⊦ #(x + y) = # x + # y; (s) ⊦ # a ' = 0 +1; (s) ⊦ m + n = m + n0 ↔ n = n0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ x + a ' ≠ []; (s) ⊦ n = # x → (x + a ')[n] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: csl, cs0, y
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, n < # cs ', aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), n ≤ # al, ¬ cstepf(cs '[n], (al + a ')[n], (csl + cs1 ')[n]), n < # al → cstepf((cs ' + csl)[n], al[n], csl[n]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, (al + a ')[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (a ' + x)[0] = a; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ a '[0] = a; (s) ⊦ 0 ≤ m; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # a ' = 0 +1; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, (al + a ')[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, al[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a '[0] = a; (s) ⊦ x + [] = x; (s) ⊦ a '.last = a; (s) ⊦ [] + σ = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜[]⌝ = []; (s) ⊦ [] + x = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a '[0] = a; (s) Used terms: 0, a ', al
| ⊦ n < # x → (x + y)[n] = x[n] |
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, 0 < # al, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, al[0], (csl + cs1 ')[0]), al ≠ [] → cstepf(cs, hd(al), csl[0]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, hd(al), csl[0]), ¬ cstepf(cs, hd(al), (csl + cs1 ')[0]) ⊦
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s)
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, hd(al), csl[0]), ¬ cstepf(cs, hd(al), (csl + cs1 ')[0]) ⊦ |
# csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , al = a0 + al1, a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf(cs, a0, csl[0]), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: al, a0, y
| # csl = # al, ⌜al⌝ ^ = ⌜al0⌝ , al = a0 + al1, a ≠ τ, al ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf(cs, a0, csl[0]), cstepf((cs ' + csl).last, a, cs1), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ |
# csl = # al1 + 1, ⌜a0 '⌝ ^ + ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, a0, csl[0]), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ a ' + x ≠ []; (s) ⊦ a + x = a ' + x; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # csl = # al1 + 1, ⌜a0 '⌝ ^ + ⌜al1⌝ ^ = ⌜al0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cstartf(cs), cstepf((cs ' + csl).last, a, cs1), cstepf(cs, a0, csl[0]), ¬ cstepf(cs, a0, (csl + cs1 ')[0]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: 0, cs1 ', csl
| ⊦ n < # x → (x + y)[n] = x[n] |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), atrace(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ ), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)), ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1) |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∃ σ, β. ⌜al0⌝ + ⌜a '⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al0⌝ + ⌜a '⌝ , astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), ∃ σ, β. ⌜al0⌝ + ⌜a '⌝ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al0⌝ + ⌜a '⌝ , as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)), ∃ as1. aafter(AIOAut(astartf, astepf))(α ^, as1)
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)), ∃ as1. aafter(AIOAut(astartf, astepf))(α ^, as1) |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), α ^ = ⌜al0 + a⌝ ∧ al0 + a ≠ [] → (∃ al1, α0. α = ⌜al1⌝ + α0 ∧ al1 ≠ [] ∧ ⌜al1⌝ ^ = ⌜al0 + a⌝ ∧ al1.last = (al0 + a).last ∧ α0 ^ = []) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(α ^, as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: α, al0 + a
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al0⌝ + ⌜a '⌝ = α ^, a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, a, cs1), α ^ = ⌜al0 + a⌝ ∧ al0 + a ≠ [] → (∃ al1, α0. α = ⌜al1⌝ + α0 ∧ al1 ≠ [] ∧ ⌜al1⌝ ^ = ⌜al0 + a⌝ ∧ al1.last = (al0 + a).last ∧ α0 ^ = []) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(α ^, as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ (x + a ').last = a; (s) ⊦ x + a = x + a '; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s)
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1) ⊦ ∃ as1. aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, as1), ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, aσ[# al1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: aσ[# al1]
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ aafter(AIOAut(astartf, astepf))(⌜al1⌝ ^, aσ[# al1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. ¬(α ^ = ⌜al1⌝ ^ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ aσ[# al1] = σ.l.last) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: aσ[# al1], ⌜al1⌝ ^, astepf, astartf
| ⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. ¬(α ^ = ⌜al1⌝ ^ ∧ aexec*(AIOAut(astartf, astepf))(σ, α) ∧ aσ[# al1] = σ.l.last) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n)
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0) ∧ ¬ #(⌜al1⌝ + α0) < ⌜# al1⌝ → afrag*(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ + α0 to # al1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: astartf, astepf, aσ, ⌜al1⌝ + α0, # al1
| ⊦ afrag(AIOAut(startf, stepf))(σ, α) ∧ ¬ # α < ⌜n⌝ → afrag*(AIOAut(startf, stepf))(σ to n + 1, α to n) |
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0) ∧ ¬ #(⌜al1⌝ + α0) < ⌜# al1⌝ → afrag*(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ + α0 to # al1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
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⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ α, σ. α ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(σ, α) ∨ ¬ astartf(σ[0]) ∨ ¬ finp(α) ∨ aσ[# al1] ≠ σ.l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ⌜al1⌝ ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ) ∨ ¬ astartf((aσ to # al1 + 1)[0]) ∨ ¬ finp(⌜al1⌝ ) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al1⌝ , aσ to # al1 + 1
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ⌜al1⌝ ^ ≠ ⌜al1⌝ ^ ∨ ¬ afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ) ∨ ¬ astartf((aσ to # al1 + 1)[0]) ∨ ¬ finp(⌜al1⌝ ) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s)
| ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ, ⌜al1⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #(⌜al1⌝ + α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < #(⌜al1⌝ + α0) → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n +1]), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used terms: ⌜al1⌝ + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #(⌜al1⌝ + α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < #(⌜al1⌝ + α0) → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n +1]), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
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σ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]), ¬ astartf((aσ to # al1 + 1)[0]) ∨ aσ[# al1] ≠ (aσ to # al1 + 1).l.last ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n)
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ (⌜a '⌝ + σ)[0] = a; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] Used terms: # al1, aσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n) |
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ¬ astartf((aσ to # al1 + 1)[0]), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
Used simplifier rules: ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
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[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: # al1, aσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = (σ to n) + ⌜σ[n] '⌝ |
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
# aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
| # aσ = (⌜# al1⌝ + # α0) + ⌜1⌝ , ⌜al0⌝ + ⌜al1.last '⌝ = ⌜al1⌝ ^, α0 ^ = [], al1.last ≠ τ, aσ[# al1] ≠ (aσ to # al1 + 1).l.last, al1 ≠ [], aafter(AIOAut(astartf, astepf))(⌜al0⌝ , as), adet(AIOAut(astartf, astepf)), afrag(AIOAut(astartf, astepf))(aσ to # al1 + 1, ⌜al1⌝ ), astartf(aσ[0]), cafter(CIOAut(cstartf, cstepf))(⌜al0⌝ , cs0), cstepf(cs0, al1.last, cs1), ¬ ⌜# al1⌝ < # aσ, ∀ n. ⌜n⌝ < ⌜# al1⌝ + # α0 → astepf(aσ[n], (⌜al1⌝ + α0)[n], aσ[n + 1]) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜al1.last '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
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
| α = ⌜af0⌝ , a ≠ τ, aafter(AIOAut(astartf, astepf))(α, as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(α, cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(α + ⌜a '⌝ ) → atrace(AIOAut(astartf, astepf))(α + ⌜a '⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜af0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜af0⌝ , cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(⌜af0⌝ ) → atrace(AIOAut(astartf, astepf))(⌜af0⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜nf⌝ + σ = ⌜nf⌝ ; (s)
| a ≠ τ, aafter(AIOAut(astartf, astepf))(⌜af0⌝ , as), adet(AIOAut(astartf, astepf)), cafter(CIOAut(cstartf, cstepf))(⌜af0⌝ , cs0), cstepf(cs0, a, cs1), ctrace(CIOAut(cstartf, cstepf))(⌜af0⌝ ) → atrace(AIOAut(astartf, astepf))(⌜af0⌝ ) ⊦ ∃ as0. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , as0) ∧ (∃ β. cafter(CIOAut(cstartf, cstepf))(β, cs1) ∧ aafter(AIOAut(astartf, astepf))(β, as0)) |
⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last)
Used simplifier rules: ⊦ aexec*(AIOAut(startf, stepf))(σ, β) ↔ aexec(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ ⌜al⌝ ^ ≠ ⌜af⌝ ; (s) Used terms: as, ⌜af0⌝ , astepf, astartf
| ⊦ aafter(AIOAut(startf, stepf))(β, s) ↔ (∃ α, σ. α ^ = β ∧ aexec*(AIOAut(startf, stepf))(σ, α) ∧ s = σ.l.last) |
The following image shows the proof tree of sequent calculus. The proved goal is at the bottom. You can click on the nodes to view additional rules. See here for details on colors in a proof tree.