| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ⊦ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ |
⊦ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)))
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), (∃ csl, al. ¬(cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as)))) ∨ (∃ cs, as. ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as))) ∨ (∃ asl, al. ¬(aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last))) ∨ (∃ csl, al, a, cs0, as0. ¬ ( cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)))) ⊦
Used terms: aINV, t, astepf, astartf, cstepf, cstartf
| ⊦ weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ↔ (∀ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last)) ∧ (∀ csl, al, a, cs0, as0. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as))) |
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), (∃ csl, al. ¬(cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) → (∃ as. t(csl.last, as) ∧ aINV(as)))) ∨ (∃ cs, as. ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as))) ∨ (∃ asl, al. ¬(aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) → aINV(asl.last))) ∨ (∃ csl, al, a, cs0, as0. ¬ ( cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstepf(csl.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl.last, as)))) ⊦ |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
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)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
⊦ bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)))
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
Used terms: cstartf, cstepf, astartf, astepf, t, cINV, aINV
| ⊦ bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))) |
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV) ↔ (∀ cs. cstartf(cs) → cINV(cs)) ∧ (∀ as. astartf(as) → aINV(as)) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ∧ (∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs), ∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ ∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → cINV(cs)
Used formulas: ∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → cINV(cs)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs), ∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as)
aINV(as), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cstartf(cs), t(cs, as), ¬ astartf(as), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦
afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ aINV(asl.last), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cINV(csl.last) → (∃ as. t(csl.last, as) ∧ aINV(as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as)
Used terms: csl.last
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cINV(csl.last) → (∃ as. t(csl.last, as) ∧ aINV(as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl.last) → cINV(csl.last), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as)
Used terms: csl.last
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl.last) → cINV(csl.last), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as), ∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl.last
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), ¬ cINV(csl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)) ⊦ ∃ as. t(csl.last, as) ∧ aINV(as), ∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl.last |
Used terms: csl, al
| aINV(as), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cstartf(cs), t(cs, as), ¬ astartf(as), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ |
aINV(as), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cstartf(cs), t(cs, as), ¬ astartf(as), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦
| aINV(as), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cstartf(cs), t(cs, as), ¬ astartf(as), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ |
Used terms: cs, as
| afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ aINV(asl.last), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ |
afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ aINV(asl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦
| afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ¬ aINV(asl.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ |
afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ as. astartf(as) → aINV(as) ⊦
| afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ as. astartf(as) → aINV(as) ⊦ |
afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), astartf(asl[0]) → aINV(asl[0]), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
Used terms: asl[0]
| afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), astartf(asl[0]) → aINV(asl[0]), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
| aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
| aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), ¬ aINV(asl.last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV((as + asl0)[0]), afrag(AIOAut(astartf, astepf))(⌜as + asl0⌝ , ⌜al0⌝ ), ¬ aINV((as + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV, astartf, astepf, al0. ¬(aINV(asl0[0]) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ) ∧ ¬ aINV(asl0.last) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0))) ⊦
Used simplifier rules: astatelist freely generated by [], +;; ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s)
| aINV((as + asl0)[0]), afrag(AIOAut(astartf, astepf))(⌜as + asl0⌝ , ⌜al0⌝ ), ¬ aINV((as + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV, astartf, astepf, al0. ¬(aINV(asl0[0]) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ) ∧ ¬ aINV(asl0.last) ∧ (∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0))) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (a ' + x)[0] = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦ |
al0 = [], aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
al0 = a0 + al1, aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
Used simplifier rules: actionlist freely generated by [], +;;
| al0 = [], aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , []), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s)
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , []), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
Used simplifier rules: ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m ≤ n → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ = n∞2); (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # x = 0 ↔ x = []; (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 ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ¬ n < 0; (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a '.last = a; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) Used terms: [], ⌜as '⌝ + ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| al0 = a0 + al1, aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜a0 '⌝ + ⌜al1⌝ ), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s)
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜as '⌝ + ⌜asl0⌝ , ⌜a0 '⌝ + ⌜al1⌝ ), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦ |
⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ afrag(AIOAut(startf, stepf))(σ, α)
aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
Used terms: ⌜al1⌝ , a0, ⌜asl0⌝ , as, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ afrag(AIOAut(startf, stepf))(σ, α) |
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ aINV0, astartf0, astepf0, al. ¬ aINV0(asl0[0]) ∨ ¬ afrag(AIOAut(astartf0, astepf0))(⌜asl0⌝ , ⌜al⌝ ) ∨ aINV0(asl0.last) ∨ ¬(∀ as, a, as0. aINV0(as) ∧ astepf0(as, a, as0) → aINV0(as0)) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ¬ aINV(asl0[0]) ∨ ¬ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∨ aINV(asl0.last) ∨ ¬(∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ⊦
Used terms: aINV, astartf, astepf, al1
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ¬ aINV(asl0[0]) ∨ ¬ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∨ aINV(asl0.last) ∨ ¬(∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0)) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ¬ aINV(asl0[0]) ∨ aINV(asl0.last) ⊦
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ¬ aINV(asl0[0]) ∨ aINV(asl0.last) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV(asl0[0]), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
aINV(as), aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV(asl0[0]), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
asl0 = as0 + asl1, aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV(asl0[0]), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
Used simplifier rules: astatelist freely generated by [], +;; ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s)
| asl0 = as0 + asl1, aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV(asl0[0]), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
aINV(as), afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al1⌝ ), astepf(as, a0, as0), ¬ aINV(as0), ¬ aINV((as0 ' + asl1).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ hd(⌜a '⌝ + ⌜x⌝ ) = a; (s)
| aINV(as), afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al1⌝ ), astepf(as, a0, as0), ¬ aINV(as0), ¬ aINV((as0 ' + asl1).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
Used terms: as, a0, as0
| aINV(as), aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ), astepf(as, a0, hd(⌜asl0⌝ )), ¬ aINV((as ' + asl0).last), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0) ⊦ |
⊦ x ≠ [] → (a ' + x).last = x.last
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) Used terms: asl0, as
| ⊦ x ≠ [] → (a ' + x).last = x.last |
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as) |
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as) |
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), cINV(csl0.last) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)
Used terms: csl0.last, a, cs0, as0
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), cINV(csl0.last) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as) |
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs1. (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs1) → cINV(cs1) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as) |
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl0.last) → cINV(csl0.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as)
Used terms: csl0.last
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), (∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl0.last) → cINV(csl0.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as) |
aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as), ∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl0.last
| aINV(as0), bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), cstepf(csl0.last, a, cs0), t(cs0, as0), ¬ cINV(csl0.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as) ⊦ ∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as), ∃ csl1, al2. cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = csl0.last |
Used terms: csl0, al1
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as. astartf(as) → aINV(as), ∀ cs. cstartf(cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ ∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → cINV(cs) |
bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| bwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, cINV, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs. cstartf(cs) → cINV(cs), ∀ as. astartf(as) → aINV(as), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ as, a, as0. aINV(as) ∧ astepf(as, a, as0) → aINV(as0), ∀ cs. cINV(cs) → (∃ as. t(cs, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ cs, a, cs0, as0. cINV(cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cs. cstartf(cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cs. cstartf(cs) → cINV(cs), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), cstartf(csl1[0]) → cINV(csl1[0]), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
Used terms: csl1[0]
| cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), cstartf(csl1[0]) → cINV(csl1[0]), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
cINV(csl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦
| cINV(csl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), cstartf(csl1[0]), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬(cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) → (∃ as. t(csl.last, as) ∧ aINV(as))) ∨ ¬(cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as)) ∨ ¬(afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) → aINV(asl.last)) ∨ ¬ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ cstepf(csl0.last, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(csl0.last, as))) ⊦ |
cINV(csl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
| cINV(csl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al2⌝ ), ¬ cINV(csl1.last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
cINV((cs + csl)[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs + csl⌝ , ⌜al2⌝ ), ¬ cINV((cs + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV, cstartf, cstepf, al2. ¬(cINV(csl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ ¬ cINV(csl.last) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0))) ⊦
Used simplifier rules: cstatelist freely generated by [], +;; ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s)
| cINV((cs + csl)[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs + csl⌝ , ⌜al2⌝ ), ¬ cINV((cs + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV, cstartf, cstepf, al2. ¬(cINV(csl[0]) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al2⌝ ) ∧ ¬ cINV(csl.last) ∧ (∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0))) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (a ' + x)[0] = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦ |
al2 = [], cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
al2 = a0 + al0, cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
Used simplifier rules: actionlist freely generated by [], +;;
| al2 = [], cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , []), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s)
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , []), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
Used simplifier rules: ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m ≤ n → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ = n∞2); (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # x = 0 ↔ x = []; (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 ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ¬ n < 0; (s) ⊦ 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: [], ⌜cs '⌝ + ⌜csl⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| al2 = a0 + al0, cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜al2⌝ ), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜a0 '⌝ + ⌜al0⌝ ), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s)
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs '⌝ + ⌜csl⌝ , ⌜a0 '⌝ + ⌜al0⌝ ), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦ |
⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ cfrag(CIOAut(startf, stepf))(σ, α)
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
Used terms: ⌜al0⌝ , a0, ⌜csl⌝ , cs, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ cfrag(CIOAut(startf, stepf))(σ, α) |
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ∀ cINV0, cstartf0, cstepf0, al. ¬ cINV0(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf0, cstepf0))(⌜csl⌝ , ⌜al⌝ ) ∨ cINV0(csl.last) ∨ ¬(∀ cs, a, cs0. cINV0(cs) ∧ cstepf0(cs, a, cs0) → cINV0(cs0)) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬ cINV(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∨ cINV(csl.last) ∨ ¬(∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ⊦
Used terms: cINV, cstartf, cstepf, al0
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬ cINV(csl[0]) ∨ ¬ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ) ∨ cINV(csl.last) ∨ ¬(∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0)) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬ cINV(csl[0]) ∨ cINV(csl.last) ⊦
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0), ¬ cINV(csl[0]) ∨ cINV(csl.last) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV(csl[0]), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
cINV(cs), cINV(csl.last), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV(csl[0]), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
csl = cs0 + csl0, cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV(csl[0]), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
Used simplifier rules: cstatelist freely generated by [], +;; ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s)
| csl = cs0 + csl0, cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV(csl[0]), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl0⌝ , ⌜al0⌝ ), cstepf(cs, a0, cs0), ¬ cINV(cs0), ¬ cINV((cs0 ' + csl0).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceC-IOstatestream] ⊦ hd(⌜a '⌝ + ⌜x⌝ ) = a; (s)
| cINV(cs), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl0⌝ , ⌜al0⌝ ), cstepf(cs, a0, cs0), ¬ cINV(cs0), ¬ cINV((cs0 ' + csl0).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
Used terms: cs, a0, cs0
| cINV(cs), cINV(csl.last), cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al0⌝ ), cstepf(cs, a0, hd(⌜csl⌝ )), ¬ cINV((cs ' + csl).last), ∀ cs, a, cs0. cINV(cs) ∧ cstepf(cs, a, cs0) → cINV(cs0) ⊦ |
⊦ x ≠ [] → (a ' + x).last = x.last
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) Used terms: csl, cs
| ⊦ x ≠ [] → (a ' + x).last = x.last |
The following image shows the proof tree of sequent calculus. The proved goal is at the bottom. You can click on the nodes to view additional rules. See here for details on colors in a proof tree.