| cforest(CIOAut(cstartf, cstepf)), C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ cs, as. ∃ asl, csl, al1, al2. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ)) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ cs, as. ∃ asl, csl, al1, al2. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ cs, as. ∃ asl, csl, al1, al2. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ)) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ cs, as. ∃ asl, csl, al1, al2. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ))
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), λ cs, as. ∃ asl, csl, al1, al2. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al1⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ)) |
⊦ bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t) ↔ (∀ cs. ∃ as. t(cs, as)) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cstepf(cs, a, cs0) ∧ t(cs0, as0) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)))
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ (∀ cs. ∃ as. ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ (∀ cs, as. cstartf(cs) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cstepf(cs, a, cs0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
Used terms: λ cs, as. ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ), astepf, astartf, cstepf, cstartf
| ⊦ bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t) ↔ (∀ cs. ∃ as. t(cs, as)) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cstepf(cs, a, cs0) ∧ t(cs0, as0) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))) |
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ (∀ cs. ∃ as. ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ (∀ cs, as. cstartf(cs) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cstepf(cs, a, cs0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), cforest(CIOAut(cstartf, cstepf)) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
⊦ cforest(CIOAut(startf, stepf)) ↔ (∀ s2. (∃ α, sl. cexec*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s2 = sl.last) ∧ (∀ α1, sl1, α2, sl2. cexec*(CIOAut(startf, stepf))(⌜sl1⌝ , α1) ∧ cexec*(CIOAut(startf, stepf))(⌜sl2⌝ , α2) ∧ s2 = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2))
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ s2. (∃ α, sl. cexec*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ s2 = sl.last) ∧ (∀ α1, sl1, α2, sl2. cexec*(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cexec*(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ s2 = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
Used terms: cstepf, cstartf
| ⊦ cforest(CIOAut(startf, stepf)) ↔ (∀ s2. (∃ α, sl. cexec*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s2 = sl.last) ∧ (∀ α1, sl1, α2, sl2. cexec*(CIOAut(startf, stepf))(⌜sl1⌝ , α1) ∧ cexec*(CIOAut(startf, stepf))(⌜sl2⌝ , α2) ∧ s2 = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2)) |
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ s2. (∃ α, sl. cexec*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ s2 = sl.last) ∧ (∀ α1, sl1, α2, sl2. cexec*(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cexec*(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ s2 = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ cexec*(CIOAut(startf, stepf))(σ, β) ↔ cexec(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α))
∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
Used terms: astepf, astartf, cstepf, cstartf
| ⊦ C_≤*T_A(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf)) ↔ (∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α)) |
| ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace*(CIOAut(cstartf, cstepf))(α) → atrace*(AIOAut(astartf, astepf))(α) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))))
Used simplifier rules: ⊦ atrace*(AIOAut(startf, stepf))(α) ↔ atrace(AIOAut(startf, stepf))(α) ∧ finp(α); (s) ⊦ ctrace*(CIOAut(startf, stepf))(α) ↔ ctrace(CIOAut(startf, stepf))(α) ∧ finp(α); (s)
| ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) ∧ ( cstartf(csl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs0 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) → astartf(asl.last)) ∧ ( cstepf(cs1, a, csl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ asl0.last = as0 ∧ csl0.last = cs2 ∧ ⌜al1⌝ ^ = ⌜al2⌝ ^ ∧ (al1 ≠ [] → al1.last ≠ τ) → (∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)))) |
∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
asl.last = as, csl.last = cs0, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl.last), cstartf(csl[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
asl0.last = as0, csl0.last = cs2, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ cs = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ cs = csl1.last ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: cs
| ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ cs = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ cs = csl1.last ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: ⌜al⌝ ^
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) ∧ finp(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^) → atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ctrace(CIOAut(cstartf, cstepf))(⌜al⌝ ^), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β))
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: ⌜al⌝ ^, cstepf, cstartf
| ⊦ ctrace(CIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ cexec(CIOAut(startf, stepf))(σ, β)) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ σ, β. ¬(⌜al⌝ ^ = β ^ ∧ cexec(CIOAut(cstartf, cstepf))(σ, β)) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ σ, β. ⌜al⌝ ^ ≠ β ^ ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(σ, β) ∨ ¬ cstartf(σ[0]) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) Used terms: ⌜csl1⌝ , ⌜al⌝
| atrace(AIOAut(astartf, astepf))(⌜al⌝ ^), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β))
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: ⌜al⌝ ^, astepf, astartf
| ⊦ atrace(AIOAut(startf, stepf))(α) ↔ (∃ σ, β. α = β ^ ∧ aexec(AIOAut(startf, stepf))(σ, β)) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ σ, β. ⌜al⌝ ^ = β ^ ∧ aexec(AIOAut(astartf, astepf))(σ, β) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| ⌜al⌝ ^ = α ^, afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⌜al⌝ ^ = α ^, α ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used formulas: α ^ = []
| ⌜al⌝ ^ = α ^, α ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
| α ^ = [], ⌜al⌝ ^ = [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) Used terms: aσ[0] ', csl1, [], al
| ⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: α, ⌜al⌝ ^.l
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| ⌜al⌝ ^ = α ^, α ^ ≠ [], afrag(AIOAut(astartf, astepf))(aσ, α), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), α ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α0. α = ⌜al0⌝ + α0 ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α0 ^ = []), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ x + [] = x; (s) ⊦ [].l = []; (s) finp(σ), finp(σ0) ⊦ (σ0 + σ).l = σ0.l + σ.l; (s) ⊦ finp(⌜al⌝ ^); (s) ⊦ finp([]); (s) ⊦ σ + σ0 = σ ↔ σ0 = [] ∨ # σ = ∞; (s) ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ ⌜al1⌝ ^.l = [] ↔ ⌜al1⌝ ^ = []; (s)
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used formulas: afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ )
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl1.last ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ ∧ (al0 ≠ [] → al0.last ≠ τ)
Used terms: (aσ to # al0 + 1).l, csl1, al0, al
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl1.last ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ ∧ (al0 ≠ [] → al0.last ≠ τ) |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(⌜(aσ to # al0 + 1).l⌝ , ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
⊦ finp(σ) → ⌜σ.l⌝ = σ
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), finp(aσ to # al0 + 1), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
Used simplifier rules: ⊦ finp(σ to m); (s) Used terms: aσ to # al0 + 1
| ⊦ finp(σ) → ⌜σ.l⌝ = σ |
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), finp(aσ to # al0 + 1), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ) ∧ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
Used simplifier rules: ⊦ finp(σ to m); (s)
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n)
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ finp(σ to m); (s) finp(σ) ⊦ (⌜a '⌝ + σ).l = a ' + σ.l; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ ⌜al⌝ ^ ≠ [] → ⌜al⌝ ^.l.last ≠ τ; (s) Used terms: # al0, aσ
| ⌜n⌝ < # σ ⊦ σ to n + 1 = σ[0] + (tl(σ) to n) |
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]) ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
Used terms: ⌜al0⌝ + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]) ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ
Used simplifier rules: ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]) ⊦ astartf((aσ to # al0 + 1).l[0]) ∧ al0.last ≠ τ |
Used simplifier rules: ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ afrag(AIOAut(astartf, astepf))(aσ to # al0 + 1, ⌜al0⌝ ), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf((aσ to # al0 + 1)[n], ⌜al0⌝ [n], (aσ to # al0 + 1)[n +1]))) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: ⌜al0⌝ , aσ to # al0 + 1, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf((aσ to # al0 + 1)[n], ⌜al0⌝ [n], (aσ to # al0 + 1)[n +1]))) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], afrag(AIOAut(astartf, astepf))(aσ, ⌜al0⌝ + α0), astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: ⌜al0⌝ + α0, aσ, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # aσ = #(⌜al0⌝ + α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n. ⌜n⌝ < #(⌜al0⌝ + α0) → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n +1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ n0. ⌜n0⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n0], (⌜al0⌝ + α0)[n0], aσ[n0 + 1]), #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: n
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used formulas: #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic 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⌝ + n∞0; (s)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]
#(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ), n < # al0 + 1 ∧ ¬ # aσ < ⌜# al0 + 1⌝
#(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, n < # al0 + 1, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ # aσ < ⌜# al0 + 1⌝ , ¬ astepf(aσ[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used terms: n, # al0 + 1, aσ
| m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m] |
| #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ), n < # al0 + 1 ∧ ¬ # aσ < ⌜# al0 + 1⌝ |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
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 < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , #(aσ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ¬ astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ ; (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)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ ⌜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σ to # al0 + 1) = ⌜1⌝ + ⌜# al0⌝ , # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, n < # al0 + 1, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ # aσ < ⌜# al0 + 1⌝ , ¬ astepf(aσ[n], al0[n], (aσ to # al0 + 1)[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, ⌜# al0⌝ < # aσ, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: m < n, ¬ # σ < ⌜n⌝ ⊦ (σ to n)[m] = σ[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ ; (s)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], ⌜al0⌝ ^ ≠ [], al0 ≠ [], n < # al0, ⌜# al0⌝ < # aσ, astartf(aσ[0]), astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ astepf(aσ[n], al0[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m]
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ¬ ⌜m⌝ < # σ → (σ + σ1)[m] = σ1[m - (# σ).n]; (s) ⊦ ⌜n⌝ .n = n; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: n, α0, ⌜al0⌝
| ⊦ ⌜m⌝ < # σ → (σ + σ1)[m] = σ[m] |
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, #(aσ to # al0 + 1) ≠ ⌜# al0⌝ + ⌜1⌝ ∨ ¬(n < # al0 → astepf((aσ to # al0 + 1)[n], al0[n], (aσ to # al0 + 1)[n + 1])) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], # aσ < ⌜# al0 + 1⌝ , astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ ⌜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)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = 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 Used terms: # al0 + 1, aσ
| ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ |
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, ⌜al⌝ ^ = ⌜al0⌝ ^, α0 ^ = [], #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], # aσ < ⌜# al0 + 1⌝ , astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
# aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)
| # aσ = (⌜# al0⌝ + # α0) + ⌜1⌝ , al0.last = ⌜al0⌝ ^.l.last, α0 ^ = [], ⌜al⌝ ^ = ⌜al0⌝ ^, #(aσ to # al0 + 1) ≠ ⌜1⌝ + ⌜# al0⌝ , ⌜al0⌝ ^ ≠ [], al0 ≠ [], astartf(aσ[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), ¬ ⌜# al0⌝ < # aσ, ⌜n⌝ < ⌜# al0⌝ + # α0 → astepf(aσ[n], (⌜al0⌝ + α0)[n], aσ[n + 1]), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ # σ < ⌜n⌝ + ⌜1⌝ ↔ ¬ ⌜n⌝ < # σ; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) ¬ # σ < ⌜n⌝ ⊦ #(σ to n) = ⌜n⌝ ; (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)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = 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
| asl.last = as, csl.last = cs0, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl.last), cstartf(csl[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl[0]), cstartf(csl.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
| ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl[0]), cstartf(csl.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl.last), cstartf(csl[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ csl.last = csl1.last ⊦
Used terms: csl.last
| ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl.last), cstartf(csl[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ csl.last = csl1.last ⊦ |
csl.last = csl1.last, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| csl.last = csl1.last, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
csl.last = csl1.last, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1.last), cstartf(csl[0]), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ) ∧ cstartf(csl1[0]) ∧ finp(⌜al1⌝ ) ∧ csl1.last = csl.last ∧ csl1.last = csl1.last → ⌜al0⌝ = ⌜al1⌝ ∧ csl = csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦
Used terms: ⌜al0⌝ , csl, ⌜al1⌝ , csl1
| csl.last = csl1.last, ⌜al⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1.last), cstartf(csl[0]), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ) ∧ cstartf(csl1[0]) ∧ finp(⌜al1⌝ ) ∧ csl1.last = csl.last ∧ csl1.last = csl1.last → ⌜al0⌝ = ⌜al1⌝ ∧ csl = csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ |
⌜al⌝ ^ = ⌜al1⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s)
| ⌜al⌝ ^ = ⌜al1⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ |
⌜al⌝ ^ = ⌜al1⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ) ∧ cstartf(csl1[0]) ∧ finp(⌜al1⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1.last '⌝ , []) ∧ cstartf(csl1.last '[0]) ∧ finp([]) ∧ csl1.last '.last = csl1.last ∧ csl1.last = csl1.last '.last → ⌜al1⌝ = [] ∧ csl1 = csl1.last ', ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used terms: ⌜al1⌝ , csl1, [], csl1.last '
| ⌜al⌝ ^ = ⌜al1⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al1⌝ ) ∧ cstartf(csl1[0]) ∧ finp(⌜al1⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1.last '⌝ , []) ∧ cstartf(csl1.last '[0]) ∧ finp([]) ∧ csl1.last '.last = csl1.last ∧ csl1.last = csl1.last '.last → ⌜al1⌝ = [] ∧ csl1 = csl1.last ', ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⌜al⌝ ^ = [], csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a '.last = a; (s) ⊦ finp([]); (s) ⊦ a '[0] = a; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ finp(⌜x⌝ ); (s)
| ⌜al⌝ ^ = [], csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ α ^ = [] ↔ (∀ n. ⌜n⌝ < # α → α[n] = τ)
csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # ⌜al⌝ → ⌜al⌝ [n] = τ ⊦
Used terms: ⌜al⌝
| ⊦ α ^ = [] ↔ (∀ n. ⌜n⌝ < # α → α[n] = τ) |
| csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # ⌜al⌝ → ⌜al⌝ [n] = τ ⊦ |
csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → al[n] = τ ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. n < # al → al[n] = τ ⊦ |
al = [], csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ n. n < # al → al[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
al = al0 + a ', csl1 = csl1.last ', al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → a ≠ τ, ∀ n. n < # al → al[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: al, a0, al0
| al = [], csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → al.last ≠ τ, ∀ n. n < # al → al[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , []), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ # [] = 0; (s) ⊦ ⌜[]⌝ = []; (s)
| csl1 = csl1.last ', afrag(AIOAut(astartf, astepf))(⌜asl⌝ , []), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl⌝ = # [] + ⌜1⌝ , csl1 = csl1.last ', astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # [] → astepf(⌜asl⌝ [n], [][n], ⌜asl⌝ [n +1]) ⊦
Used terms: [], ⌜asl⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl⌝ = # [] + ⌜1⌝ , csl1 = csl1.last ', astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ⌜n⌝ < # [] → astepf(⌜asl⌝ [n], [][n], ⌜asl⌝ [n +1]) ⊦ |
# asl = 1, csl1 = csl1.last ', astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # asl = 1, csl1 = csl1.last ', astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
Used simplifier rules: astatelist freely generated by [], +;; ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ (a ' + x)[0] = a; (s) ⊦ a + x = a ' + x; (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a '.last = a; (s) ⊦ # [] = 0; (s)
| al = al0 + a ', csl1 = csl1.last ', al ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1.last), cstartf(csl1[0]), ¬ astartf(asl.last), al ≠ [] → a ≠ τ, ∀ n. n < # al → al[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
csl1 = csl1.last ', a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ + ⌜a '⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ n. ¬ # al0 < n → (al0 + a ')[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ x + a ' ≠ []; (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) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| csl1 = csl1.last ', a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ + ⌜a '⌝ ), astartf(asl[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , []), cstartf(csl1[0]), cstartf(csl1.last), ¬ astartf(asl.last), ∀ n. ¬ # al0 < n → (al0 + a ')[n] = τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
Used simplifier rules: ⊦ ¬ n < n; (s) ⊦ (x + a ')[# x] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: # al0
| asl0.last = as0, csl0.last = cs2, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ cs1 = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ cs1 = csl1.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: cs1
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl0[0]), cstepf(cs1, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ cs1 = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ cs1 = csl1.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = cs1 ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl1.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl0[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl0.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ csl0.last = csl1.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: csl0.last
| ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl0.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ csl0.last = csl1.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl0.last = csl.last, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl0[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| csl0.last = csl.last, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl0[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl0.last = csl.last, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ finp(⌜al2⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ csl.last = csl0.last ∧ csl.last = csl.last → ⌜al2⌝ = ⌜al0⌝ ∧ csl0 = csl, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: ⌜al2⌝ , csl0, ⌜al0⌝ , csl
| csl0.last = csl.last, ⌜al1⌝ ^ = ⌜al2⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl0[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al2⌝ ) ∧ cstartf(csl0[0]) ∧ finp(⌜al2⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ csl.last = csl0.last ∧ csl.last = csl.last → ⌜al2⌝ = ⌜al0⌝ ∧ csl0 = csl, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ finp(⌜x⌝ ); (s)
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ csl.last = sl2.last → α1 = α2 ∧ sl1 = sl2 ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1 + csl.last⌝ , ⌜al + a⌝ ) ∧ cstartf((csl1 + csl.last)[0]) ∧ finp(⌜al + a⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ csl.last = (csl1 + csl.last).last ∧ csl.last = csl.last → ⌜al + a⌝ = ⌜al0⌝ ∧ csl1 + csl.last = csl, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: ⌜al + a⌝ , csl1 + csl.last, ⌜al0⌝ , csl
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1 + csl.last⌝ , ⌜al + a⌝ ) ∧ cstartf((csl1 + csl.last)[0]) ∧ finp(⌜al + a⌝ ) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ finp(⌜al0⌝ ) ∧ csl.last = (csl1 + csl.last).last ∧ csl.last = csl.last → ⌜al + a⌝ = ⌜al0⌝ ∧ csl1 + csl.last = csl, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ + ⌜csl.last '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl1 + csl.last ')[0]) → al + a ' = al0 ∧ csl1 + csl.last ' = csl, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ x + a = x + a '; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ + ⌜csl.last '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl1 + csl.last ')[0]) → al + a ' = al0 ∧ csl1 + csl.last ' = csl, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ + ⌜csl.last '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl1 + csl.last ')[0])
al + a ' = al0, csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ + ⌜csl.last '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl1 + csl.last ')[0]) |
⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α)
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), (cstepf(csl1.last, a, csl.last) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ )) ∧ cstartf((csl1 + csl.last ')[0])
Used terms: a, ⌜al⌝ , csl.last, csl1, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α) |
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstartf(csl1[0]), cstartf(csl[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), (cstepf(csl1.last, a, csl.last) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ )) ∧ cstartf((csl1 + csl.last ')[0]) |
⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), ¬ cstartf((csl1 + csl.last ')[0]), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), ¬ cstartf((csl1 + csl.last ')[0]), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: 0, csl.last ', csl1
| ⊦ n < # x → (x + y)[n] = x[n] |
| al + a ' = al0, csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al0⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl[0]), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), cstartf(hd(csl)), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ x.last ∈ x ↔ x ≠ []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[traceC-IOstatestream] a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(csl1[0]), cstartf(hd(csl)), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl = cs + csl0, csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl, cs, csl0
| csl1 + csl.last ' = csl, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl = cs + csl0, csl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl.last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + (cs ' + csl0).last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, (cs ' + csl0).last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), cs ∈ csl1 ∨ cs = (cs ' + csl0).last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) ⊦ a ' + x ≠ []; (s) ⊦ x.last ∈ x ↔ x ≠ []; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[traceC-IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s)
| csl1 + (cs ' + csl0).last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, (cs ' + csl0).last), al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), cs ∈ csl1 ∨ cs = (cs ' + csl0).last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ y ≠ [] → (x + y).last = y.last
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), cs ∈ csl1 ∨ cs = csl0.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ a ' = x + b ' ↔ a = b ∧ x = []; (ws) ⊦ σ + [] = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a '.last = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: csl0, cs '
| ⊦ y ≠ [] → (x + y).last = y.last |
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), cs ∈ csl1 ∨ cs = csl0.last ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a ∈ x → a ∈ x + y; (s) ⊦ x.last ∈ x ↔ x ≠ []; (s) ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list[traceC-IOstatestream] in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list[traceC-IOstatestream] inapp-07: ⊦ a ' + x = y + b ' ∧ x ≠ [] → a ∈ y ∧ b ∈ x; (forward) from specification list[traceC-IOstatestream]
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 = [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used formulas: al1 ≠ []
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1.last ≠ τ, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1.last ≠ τ, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 = al2 + a0 ', a0 ≠ τ, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: al1, a0, al2
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 = al2 + a0 ', a0 ≠ τ, al1 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a ' ≠ []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝
⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl1 + csl0.last ' = cs ' + csl0, a = τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , csl1 + csl0.last ' = cs ' + csl0, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: a
| ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ |
| ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ ^, csl1 + csl0.last ' = cs ' + csl0, a = τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, csl1 + csl0.last ' = cs ' + csl0, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(asl0.last, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0.last ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: asl0.last
| ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, csl1 + csl0.last ' = cs ' + csl0, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(asl0.last, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0.last ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0.last ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ amove(AIOAut(startf, stepf))(s, [], s); (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0.last ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ x + a ' ≠ []; (s) ⊦ x + a = x + a '; (s) ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: asl0, csl1, al2 + a0, al
| ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , csl1 + csl0.last ' = cs ' + csl0, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ finp(σ) ∧ # σ = # σ1 → (σ + σ0 = σ1 + σ2 ↔ σ = σ1 ∧ σ0 = σ2)
⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , csl1 + csl0.last ' = cs ' + csl0, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), finp(⌜al2⌝ ^) ∧ # ⌜al2⌝ ^ = # ⌜al⌝ ^
# ⌜al2⌝ ^ = # ⌜al⌝ ^, csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜a0 '⌝ = ⌜a '⌝ , a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), finp(⌜al2⌝ ^), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: ⌜a '⌝ , ⌜al⌝ ^, ⌜a0 '⌝ , ⌜al2⌝ ^
| ⊦ finp(σ) ∧ # σ = # σ1 → (σ + σ0 = σ1 + σ2 ↔ σ = σ1 ∧ σ0 = σ2) |
| ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , csl1 + csl0.last ' = cs ' + csl0, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)), finp(⌜al2⌝ ^) ∧ # ⌜al2⌝ ^ = # ⌜al⌝ ^ |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , # ⌜al2⌝ ^ ≠ # ⌜al⌝ ^, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ + ⌜a0 '⌝ = ⌜al⌝ ^ + ⌜a '⌝ , # ⌜al2⌝ ^ ≠ # ⌜al⌝ ^, a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ σ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 '⌝ , ⌜al2⌝ ^ + ⌜a0 '⌝
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| # ⌜al2⌝ ^ = # ⌜al⌝ ^, csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜a0 '⌝ = ⌜a '⌝ , a ≠ τ, a0 ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a0 '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), finp(⌜al2⌝ ^), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ finp(⌜al⌝ ^); (s) ⊦ a ' = b ' ↔ a = b; (s) ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used formulas: ⌜al2⌝ ^ = []
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ amove(AIOAut(astartf, astepf))(asl0[0], ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: asl0[0]
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ amove(AIOAut(astartf, astepf))(asl0[0], ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ amove(AIOAut(astartf, astepf))(asl0[0], ⌜a '⌝ , asl0.last), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ amove(AIOAut(astartf, astepf))(asl0[0], ⌜a '⌝ , asl0.last), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[0] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦
Used terms: asl0.last, ⌜a '⌝ , asl0[0], astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[0] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[0] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[0] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
Used simplifier rules: ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) finp(σ) ⊦ σ0 + σ = σ ↔ σ0 = []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] Used terms: ⌜al2⌝ + ⌜a '⌝ , asl0
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], ⌜al2⌝ ^ = [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ a '.last = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) Used terms: asl0[0] ', csl1, [], al
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = [])
csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ⌜al2⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α. ⌜al2⌝ = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α ^ = []), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: ⌜al2⌝ , ⌜al⌝ ^.l
| ⊦ β ^ = ⌜al⌝ ∧ al ≠ [] → (∃ al0, α. β = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜al⌝ ∧ al0.last = al.last ∧ α ^ = []) |
| csl1 + csl0.last ' = cs ' + csl0, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ⌜al2⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ ⌜al⌝ ^.l ≠ [] → (∃ al0, α. ⌜al2⌝ = ⌜al0⌝ + α ∧ al0 ≠ [] ∧ ⌜al0⌝ ^ = ⌜⌜al⌝ ^.l⌝ ∧ al0.last = ⌜al⌝ ^.l.last ∧ α ^ = []), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al0⌝ ^ = ⌜al⌝ ^, α ^ = [], ⌜al2⌝ = ⌜al0⌝ + α, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ ⌜al1⌝ ^.l = [] ↔ ⌜al1⌝ ^ = []; (s)
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al2⌝ ^ = ⌜al⌝ ^, ⌜al0⌝ ^ = ⌜al⌝ ^, α ^ = [], ⌜al2⌝ = ⌜al0⌝ + α, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, α ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜al⌝ ^, α = ⌜al1⌝ , ⌜al2⌝ = ⌜al0⌝ + α, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: actionstream freely generated by ⌜ ⌝, ⌜ ⌝;; ⊦ ⌜x⌝ ≠ σ + ⌜nf0⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream]
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, α ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al2⌝ ^ = ⌜al⌝ ^, α = ⌜al1⌝ , ⌜al2⌝ = ⌜al0⌝ + α, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) ⊦ ⌜x⌝ + ⌜y⌝ = ⌜z⌝ ↔ x + y = z; (s)
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ amove(AIOAut(astartf, astepf))(asl0[# al0], ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[# al0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al1⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: asl0[# al0]
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ amove(AIOAut(astartf, astepf))(asl0[# al0], ⌜a '⌝ , asl0.last) ∧ (∃ asl, csl, al, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[# al0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al1⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ amove(AIOAut(astartf, astepf))(asl0[# al0], ⌜a '⌝ , asl0.last), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[# al0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al1⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ amove(AIOAut(astartf, astepf))(asl0[# al0], ⌜a '⌝ , asl0.last), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[# al0] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦
Used terms: asl0.last, ⌜a '⌝ , asl0[# al0], astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α, sl. ¬(afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ asl0[# al0] = sl[0] ∧ asl0.last = sl.last ∧ α ^ = ⌜a '⌝ ) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[# al0] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦
Used simplifier rules: ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ α, sl. ¬ afrag(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ asl0[# al0] ≠ sl[0] ∨ asl0.last ≠ sl.last ∨ α ^ ≠ ⌜a '⌝ ⊦ |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1 + a⌝ ) ∨ ¬ finp(⌜al1 + a⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ∨ ⌜al1 + a⌝ ^ ≠ ⌜a '⌝ ⊦
Used terms: ⌜al1 + a⌝ , asl0 from # al0
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1 + a⌝ ) ∨ ¬ finp(⌜al1 + a⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ∨ ⌜al1 + a⌝ ^ ≠ ⌜a '⌝ ⊦ |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] finp(σ) ⊦ σ0 + σ = σ ↔ σ0 = []; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ 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 = x + a '; (s) ⊦ finp(⌜x⌝ + σ) ↔ finp(σ); (s)
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl0⌝ = #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) → astepf(⌜asl0⌝ [n], ((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ )[n], ⌜asl0⌝ [n +1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦
Used terms: (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ , ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl0⌝ = #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) → astepf(⌜asl0⌝ [n], ((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ )[n], ⌜asl0⌝ [n +1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ + ⌜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 ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n1⌝ + ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n1 + n + m = n0; (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) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ) ∨ asl0[# al0] ≠ (asl0 from # al0)[0] ∨ asl0.last ≠ (asl0 from # al0).last ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0.last ≠ (asl0 from # al0).last, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 from # al0⌝ , ⌜al1⌝ + ⌜a '⌝ ), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # ⌜asl0 from # al0⌝ ≠ #(⌜al1⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al1⌝ + ⌜a '⌝ ) → astepf(⌜asl0 from # al0⌝ [n], (⌜al1⌝ + ⌜a '⌝ )[n], ⌜asl0 from # al0⌝ [n +1]))) ⊦
Used terms: ⌜al1⌝ + ⌜a '⌝ , ⌜asl0 from # al0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # ⌜asl0 from # al0⌝ ≠ #(⌜al1⌝ + ⌜a '⌝ ) + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < #(⌜al1⌝ + ⌜a '⌝ ) → astepf(⌜asl0 from # al0⌝ [n], (⌜al1⌝ + ⌜a '⌝ )[n], ⌜asl0 from # al0⌝ [n +1]))) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), 2 + # al1 ≠ # asl0 - # al0 ∨ ¬(¬ # al1 < n → astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1])) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (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) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ ¬ m + n < m; (s) ⊦ # x = 0 ↔ x = []; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), 2 + # al1 ≠ # asl0 - # al0 ∨ ¬(¬ # al1 < n → astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1])) ⊦ |
# asl0 = n0 + # al0, csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), 2 + # al1 ≠ n0 ∨ ¬(¬ # al1 < n → astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1])) ⊦
Used simplifier rules: ⊦ m ≤ n ↔ ¬ n < m; (ss) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # asl0, # al0, n0
| # asl0 = n0 + # al0, csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), 2 + # al1 ≠ n0 ∨ ¬(¬ # al1 < n → astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1])) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, n ≤ # al1, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, n ≤ # al1, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ # al0 + n < # asl0, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], # al0 + n < # asl0, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used terms: n, # al0, asl0
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ # al0 + n < # asl0, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0 + n, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
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; (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0 + n, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf((asl0 from # al0)[n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
Used simplifier rules: ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ m ≤ m + n; (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ 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
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], # al0 + n < # asl0, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], (asl0 from # al0)[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, n ≤ # al1, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], asl0[# al0 + n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ x ≠ [] → x[0] = hd(x); (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m = n + 1 → ¬ m ≤ n; (s) ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ m; (s) n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s) eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl0, n ≤ # al1, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], asl0[# al0 + n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0 = as + asl, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], asl0[# al0 + n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as, asl
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0 = as + asl, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl0, ¬ astepf(asl0[# al0 + n], (al1 + a ')[n], asl0[# al0 + n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
# asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl + 1, ¬ astepf((as ' + asl)[# al0 + n], (al1 + a ')[n], asl[# al0 + n]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. ¬ # al0 + # al1 < n0 → astepf((as ' + asl)[n0], (al0 + al1 + a ')[n0], asl[n0]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ a + x = a ' + x; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s) n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s)
| # asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], n < 2 + # al1, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al1, # al0 ≤ # asl + 1, ¬ astepf((as ' + asl)[# al0 + n], (al1 + a ')[n], asl[# al0 + n]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n0. ¬ # al0 + # al1 < n0 → astepf((as ' + asl)[n0], (al0 + al1 + a ')[n0], asl[n0]) ⊦ |
Used simplifier rules: ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ (x + y)[n + # x] = y[n]; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: # al0 + n
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # al0 + 0 < # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
Used simplifier rules: ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: 0, # al0, asl0
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # al0 + 0 < # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0[# al0] ≠ (asl0 from # al0)[0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
Used simplifier rules: ⊦ m + m0 ≤ m ↔ m0 = 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
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, asl0.last ≠ (asl0 from # al0).last, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0 = asl + as ', ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], as ≠ (asl0 from # al0).last, asl0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
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 x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: asl0, as, asl
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0 = asl + as ', ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], as ≠ (asl0 from # al0).last, asl0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
# asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], as ≠ (asl + as ' from # al0).last, csl0 ≠ [], astartf((asl + as ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf((asl + as ')[n], (al0 + al1 + a ')[n], (asl + as ')[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ x + a ' ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s)
| # asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], as ≠ (asl + as ' from # al0).last, csl0 ≠ [], astartf((asl + as ')[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf((asl + as ')[n], (al0 + al1 + a ')[n], (asl + as ')[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
⊦ n ≤ # x → x + y from n = (x from n) + y
Used simplifier rules: ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ # x < n → x + y from n = y from (n - # x); (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: # al0, as ', asl
| ⊦ n ≤ # x → x + y from n = (x from n) + y |
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ asl, csl, al, al1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al1⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = asl0[# al0] ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al1⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ) ∧ cstartf(csl1[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ csl1.last = csl1.last ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ ∧ (al0 ≠ [] → al0.last ≠ τ)
Used terms: asl0 to # al0 + 1, csl1, al0, al
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ) ∧ cstartf(csl1[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ csl1.last = csl1.last ∧ ⌜al0⌝ ^ = ⌜al⌝ ^ ∧ (al0 ≠ [] → al0.last ≠ τ) |
csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ
| csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl0⌝ = #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) → astepf(⌜asl0⌝ [n], ((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ )[n], ⌜asl0⌝ [n +1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ
Used terms: (⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ , ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl0⌝ = #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < #((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ ) → astepf(⌜asl0⌝ [n], ((⌜al0⌝ + ⌜al1⌝ ) + ⌜a '⌝ )[n], ⌜asl0⌝ [n +1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜x⌝ + ⌜x0⌝ + ⌜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 ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ ⌜n1⌝ + ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n1 + n + m = n0; (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) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ) ∧ astartf((asl0 to # al0 + 1)[0]) ∧ (asl0 to # al0 + 1).last = asl0[# al0] ∧ al0.last ≠ τ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: ⊦ ⌜al⌝ ^ ≠ [] → ⌜al⌝ ^.l.last ≠ τ; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ afrag(AIOAut(astartf, astepf))(⌜asl0 to # al0 + 1⌝ , ⌜al0⌝ ), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # ⌜asl0 to # al0 + 1⌝ ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf(⌜asl0 to # al0 + 1⌝ [n], ⌜al0⌝ [n], ⌜asl0 to # al0 + 1⌝ [n +1]))) ⊦
Used terms: ⌜al0⌝ , ⌜asl0 to # al0 + 1⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # ⌜asl0 to # al0 + 1⌝ ≠ # ⌜al0⌝ + ⌜1⌝ ∨ (∃ n. ¬(⌜n⌝ < # ⌜al0⌝ → astepf(⌜asl0 to # al0 + 1⌝ [n], ⌜al0⌝ [n], ⌜asl0 to # al0 + 1⌝ [n +1]))) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦ |
¬ # x < n ⊦ #(x to n) = n
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], # asl0 < # al0 + 1, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # asl0 < # al0 + 1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # al0 + 1 ≠ # al0 + 1 ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦
Used terms: # al0 + 1, asl0
| ¬ # x < n ⊦ #(x to n) = n |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], # asl0 < # al0 + 1, astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), # al0 + 1 ≠ #(asl0 to # al0 + 1) ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦ |
Used simplifier rules: ⊦ m + m0 ≤ m ↔ m0 = 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
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # asl0 < # al0 + 1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), # al0 + 1 ≠ # al0 + 1 ∨ ¬(n < # al0 → astepf((asl0 to # al0 + 1)[n], al0[n], (asl0 to # al0 + 1)[n + 1])) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], # al0 < # asl0, n < # al0, n + 1 < # asl0, n < # asl0, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al0 + # al1, ¬ astepf(asl0[n], al0[n], asl0[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s) n < n0 ⊦ m + (* n) < m0 + (* n0) ↔ m < m0 + (n0 - n); (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ x ≠ [] → x[0] = hd(x); (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m +1 = m + 1; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic trans: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → ¬ n < m; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], # al0 < # asl0, n < # al0, n + 1 < # asl0, n < # asl0, astartf(hd(asl0)), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al0 + # al1, ¬ astepf(asl0[n], al0[n], asl0[n + 1]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0 = as + asl, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < # asl0, n + 1 < # asl0, n < # al0, # al0 < # asl0, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al0 + # al1, ¬ astepf(asl0[n], al0[n], asl0[n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
Used simplifier rules: x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as, asl
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], asl0 = as + asl, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl0 ≠ [], csl0 ≠ [], n < # asl0, n + 1 < # asl0, n < # al0, # al0 < # asl0, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, n ≤ # al0 + # al1, ¬ astepf(asl0[n], al0[n], asl0[n + 1]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
# asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl ≠ [], csl0 ≠ [], n < # asl, n < # al0, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl, n ≤ # al0 + # al1, ¬ astepf((as ' + asl)[n], al0[n], asl[n]), ∀ n0. ¬ # al0 + # al1 < n0 → astepf((as ' + asl)[n0], (al0 + al1 + a ')[n0], asl[n0]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦
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) ⊦ # x = 0 ↔ x = []; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (a ' + x)[n + 1] = x[n]; (s) ⊦ a + x = a ' + x; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → ¬ n < m; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ a ' + x ≠ []; (s) n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s)
| # asl = # al0 + # al1 + 1, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], asl ≠ [], csl0 ≠ [], n < # asl, n < # al0, astartf(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # al0 ≤ # asl, n ≤ # al0 + # al1, ¬ astepf((as ' + asl)[n], al0[n], asl[n]), ∀ n0. ¬ # al0 + # al1 < n0 → astepf((as ' + asl)[n0], (al0 + al1 + a ')[n0], asl[n0]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ |
Used simplifier rules: ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ n < # x → (x + y)[n] = x[n]; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] Used terms: n
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
¬ # x < n, m < n ⊦ (x to n)[m] = x[m]
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ ¬ # asl0 < # al0 + 1 ∧ 0 < # al0 + 1
Used terms: 0, # al0 + 1, asl0
| ¬ # x < n, m < n ⊦ (x to n)[m] = x[m] |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ ¬ # asl0 < # al0 + 1 ∧ 0 < # al0 + 1 |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ¬ astartf((asl0 to # al0 + 1)[0]), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
Used simplifier rules: ⊦ m + m0 ≤ m ↔ m0 = 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
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
m < # x ⊦ x to m + 1 = (x to m) + x[m] '
csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # al0 < # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦
Used simplifier rules: ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] Used terms: # al0, asl0
| m < # x ⊦ x to m + 1 = (x to m) + x[m] ' |
| csl1 + csl0.last ' = cs ' + csl0, 2 + # al0 + # al1 = # asl0, al0.last = ⌜al⌝ ^.l.last, ⌜al0⌝ ^ = ⌜al⌝ ^, ⌜al1⌝ ^ = [], (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, ¬ # al0 < # asl0, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]) ⊦ |
2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)
| 2 + # al0 + # al1 = # asl0, csl1 + csl0.last ' = cs ' + csl0, al0.last = ⌜al⌝ ^.l.last, ⌜al1⌝ ^ = [], ⌜al0⌝ ^ = ⌜al⌝ ^, (asl0 to # al0 + 1).last ≠ asl0[# al0], ⌜al⌝ ^ ≠ [], a ≠ τ, al0 ≠ [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, # asl0 ≤ # al0, ∀ n. ¬ # al0 + # al1 < n → astepf(asl0[n], (al0 + al1 + a ')[n], asl0[n + 1]), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ |
Used simplifier rules: ⊦ m + m0 ≤ m ↔ m0 = 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
| csl1 + csl0.last ' = cs ' + csl0, ⌜al1⌝ ^ = ⌜al⌝ ^ + ⌜a '⌝ ^, al1 = [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜a '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, a, csl0.last), cs ∈ csl1, al1 ≠ [] → al1.last ≠ τ, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , []), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ ⌜τ '⌝ ^ = []; (s) ⊦ ⌜[]⌝ = []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ [] ^ = []; (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , []), astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜asl0⌝ = # [] + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < # [] → astepf(⌜asl0⌝ [n], [][n], ⌜asl0⌝ [n +1]) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: [], ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜asl0⌝ = # [] + ⌜1⌝ , csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ n. ⌜n⌝ < # [] → astepf(⌜asl0⌝ [n], [][n], ⌜asl0⌝ [n +1]) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
# asl0 = 1, csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ ¬ n < 0; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # asl0 = 1, csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
# asl0 = 1, csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], asl0 = as0 + asl1, csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: astatelist freely generated by [], +;; ⊦ # [] = 0; (s)
| # asl0 = 1, csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], asl0 = as0 + asl1, csl0 ≠ [], astartf(asl0[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], asl0.last) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used simplifier rules: ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ x + [] = x; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, [], as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(as0, [], as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ))
Used terms: as0
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cstartf(cs), cstartf(csl1[0]), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2), ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α) ⊦ amove(AIOAut(astartf, astepf))(as0, [], as0) ∧ (∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)) |
csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ)
Used simplifier rules: ⊦ amove(AIOAut(startf, stepf))(s, [], s); (s)
| csl1 + csl0.last ' = cs ' + csl0, ⌜al⌝ ^ = [], csl0 ≠ [], astartf(as0), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl0⌝ , ⌜al⌝ + ⌜τ '⌝ ), cstartf(csl1[0]), cstartf(cs), cstepf(csl1.last, τ, csl0.last), cs ∈ csl1, ∀ α. ctrace(CIOAut(cstartf, cstepf))(α) ∧ finp(α) → atrace(AIOAut(astartf, astepf))(α), ∀ s2. (∃ α, csl1. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , α) ∧ cstartf(csl1[0]) ∧ finp(α) ∧ s2 = csl1.last) ∧ (∀ α1, sl1, α2, sl2. cfrag(CIOAut(cstartf, cstepf))(⌜sl1⌝ , α1) ∧ cstartf(sl1[0]) ∧ finp(α1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜sl2⌝ , α2) ∧ cstartf(sl2[0]) ∧ finp(α2) ∧ sl2.last = sl1.last ∧ s2 = sl2.last → α1 = α2 ∧ sl1 = sl2) ⊦ ∃ asl, csl, al, al0. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∧ cstartf(csl[0]) ∧ asl.last = as0 ∧ csl.last = csl1.last ∧ ⌜al⌝ ^ = ⌜al0⌝ ^ ∧ (al ≠ [] → al.last ≠ τ) |
Used simplifier rules: ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ a '.last = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s) Used terms: as0 ', csl1, [], al
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.