| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ bwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, λ cs. ∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs, λ as. aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.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)))
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ (∀ cs. cstartf(cs) → (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs)) ∧ (∀ as. astartf(as) → aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ (∀ cs, a, cs0. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) ∧ cstepf(cs, a, cs0) → (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs0)) ∧ (∀ as, a, as0. (aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ astepf(as, a, as0) → aINV(as0) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as0)) ∧ (∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → (∃ as. t(cs, as) ∧ aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as0) → (∃ as. (aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as)))
Used terms: λ as. aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as), λ cs. ∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs, t, astepf, astartf, cstepf, cstartf
| ⊦ 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))) |
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ (∀ cs. cstartf(cs) → (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs)) ∧ (∀ as. astartf(as) → aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ (∀ cs, a, cs0. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) ∧ cstepf(cs, a, cs0) → (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs0)) ∧ (∀ as, a, as0. (aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ astepf(as, a, as0) → aINV(as0) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as0)) ∧ (∀ cs. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) → (∃ as. t(cs, as) ∧ aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as))) ∧ (∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as) → astartf(as)) ∧ (∀ cs, a, cs0, as0. (∃ csl, al. cexec(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ csl.last = cs) ∧ cstepf(cs, a, cs0) ∧ t(cs0, as0) ∧ aINV(as0) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as0) → (∃ as. (aINV(as) ∧ (∃ asl, al. aexec(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ asl.last = as)) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a '⌝ ^, as0) ∧ t(cs, as))) |
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)))
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s)
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4))) |
⊦ 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)))
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))) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)))
Used terms: cstartf, cstepf, 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))) |
| 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))) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4))) |
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)))
Used simplifier rules: ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ aexec(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ (cstartf(cs) → (∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs)) ∧ (astartf(as) → aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs0 ∧ cstepf(csl.last, a, cs1) → (∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1)) ∧ ( aINV(asl.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as0 ∧ astepf(asl.last, a0, as1) → aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs2 → (∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2))) ∧ ( cstartf(cs3) ∧ t(cs3, asl0.last) ∧ aINV(asl0.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2 → astartf(asl0.last)) ∧ ( cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ csl1.last = cs4 ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) ∧ afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ) ∧ astartf(asl1[0]) ∧ asl1.last = as3 → (∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4))) |
cstartf(cs), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs
astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)
csl.last = cs0, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1
asl.last = as0, aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)
csl0.last = cs2, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
asl0.last = as2, aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ), astartf(asl0[0]), cstartf(cs3), t(cs3, asl0.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl0.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦
csl1.last = cs4, asl1.last = as3, aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)
| cstartf(cs), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs |
cstartf(cs), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs
| cstartf(cs), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ csl, al. cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ) ∧ cstartf(csl[0]) ∧ csl.last = cs |
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ a '.last = a; (s) Used terms: cs ', []
| astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as) |
astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)
| astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as) |
astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜as '⌝ , ⌜[]⌝ ) ∧ astartf(as '[0]) → aINV(as '.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as)
Used terms: as ', []
| astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜as '⌝ , ⌜[]⌝ ) ∧ astartf(as '[0]) → aINV(as '.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as) |
aINV(as), astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as
Used simplifier rules: ⊦ a '.last = a; (s) ⊦ a '[0] = a; (s) ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ ⌜[]⌝ = []; (s)
| aINV(as), astartf(as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl, al. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = as |
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ a '[0] = a; (s) ⊦ a '.last = a; (s) Used terms: as ', []
| csl.last = cs0, cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1 |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ csl0, al0. cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ) ∧ cstartf(csl0[0]) ∧ csl0.last = cs1 |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl + cs1⌝ , ⌜al + a⌝ ) ∧ cstartf((csl + cs1)[0]) ∧ (csl + cs1).last = cs1
Used terms: csl + cs1, al + a
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl + cs1⌝ , ⌜al + a⌝ ) ∧ cstartf((csl + cs1)[0]) ∧ (csl + cs1).last = cs1 |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl + cs1 ')[0])
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ x + a = x + a '; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ + ⌜cs1 '⌝ , ⌜al⌝ + ⌜a '⌝ ) ∧ cstartf((csl + cs1 ')[0]) |
⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α)
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (cstepf(csl.last, a, cs1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ )) ∧ cstartf((csl + cs1 ')[0])
Used terms: a, ⌜al⌝ , cs1, csl, cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ cfrag(CIOAut(startf, stepf))(⌜sl⌝ , α) |
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (cstepf(csl.last, a, cs1) ∧ cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ )) ∧ cstartf((csl + cs1 ')[0]) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cstartf((csl + cs1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦
| cfrag(CIOAut(cstartf, cstepf))(⌜csl⌝ , ⌜al⌝ ), cstartf(csl[0]), cstepf(csl.last, a, cs1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cstartf((csl + cs1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ |
⊦ 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, cs1 ', csl
| ⊦ n < # x → (x + y)[n] = x[n] |
| asl.last = as0, aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl + as1⌝ , ⌜al0 + a0⌝ ) ∧ astartf((asl + as1)[0]) → aINV((asl + as1).last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)
Used terms: asl + as1, al0 + a0
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl + as1⌝ , ⌜al0 + a0⌝ ) ∧ astartf((asl + as1)[0]) → aINV((asl + as1).last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ x + a = x + a '; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ aINV(as1) ∧ (∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0])
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) |
⊦ afrag(AIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ afrag(AIOAut(startf, stepf))(⌜sl⌝ , α)
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (astepf(asl.last, a0, as1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ )) ∧ astartf((asl + as1 ')[0])
Used terms: a0, ⌜al0⌝ , as1, asl, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ afrag(AIOAut(startf, stepf))(⌜sl⌝ , α) |
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (astepf(asl.last, a0, as1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ )) ∧ astartf((asl + as1 ')[0]) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ¬ astartf((asl + as1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ aINV(as1), ¬ astartf((asl + as1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) Used terms: 0, as1 ', asl
| ⊦ n < # x → (x + y)[n] = x[n] |
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl0, al1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al1⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as1 |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl + as1⌝ , ⌜al0 + a0⌝ ) ∧ astartf((asl + as1)[0]) ∧ (asl + as1).last = as1
Used terms: asl + as1, al0 + a0
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) → aINV(as1), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl + as1⌝ , ⌜al0 + a0⌝ ) ∧ astartf((asl + as1)[0]) ∧ (asl + as1).last = as1 |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0])
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ x + a = x + a '; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x + a = x + a '; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ + ⌜as1 '⌝ , ⌜al0⌝ + ⌜a0 '⌝ ) ∧ astartf((asl + as1 ')[0]) |
⊦ afrag(AIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ afrag(AIOAut(startf, stepf))(⌜sl⌝ , α)
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (astepf(asl.last, a0, as1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ )) ∧ astartf((asl + as1 ')[0])
Used terms: a0, ⌜al0⌝ , as1, asl, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(⌜sl⌝ + ⌜s '⌝ , α + ⌜a '⌝ ) ↔ stepf(sl.last, a, s) ∧ afrag(AIOAut(startf, stepf))(⌜sl⌝ , α) |
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ (astepf(asl.last, a0, as1) ∧ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ )) ∧ astartf((asl + as1 ')[0]) |
aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf((asl + as1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦
| aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al0⌝ ), astartf(asl[0]), astepf(asl.last, a0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf((asl + as1 ')[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
Used simplifier rules: ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) Used terms: 0, as1 ', asl
| ⊦ n < # x → (x + y)[n] = x[n] |
| csl0.last = cs2, cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) → (∃ as. t(csl0.last, as) ∧ aINV(as)), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used terms: csl0, al1
| cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ) ∧ cstartf(csl0[0]) → (∃ as. t(csl0.last, as) ∧ aINV(as)), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as)
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cexec(CIOAut(cstartf, cstepf))(⌜hd(csl0) '⌝ , ⌜[]⌝ ) ∧ hd(csl0) '.last = hd(csl0) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl0), ⌜⌜al1⌝ ^.l⌝ , csl0.last)
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜⌜al1⌝ ^.l⌝ , as) ∧ t(hd(csl0), as1) ∧ aINV(as1) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used terms: cstartf, cstepf, astartf, astepf, t, aINV, hd(csl0) ', [], hd(csl0), ⌜al1⌝ ^.l, csl0.last, as
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as) |
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cexec(CIOAut(cstartf, cstepf))(⌜hd(csl0) '⌝ , ⌜[]⌝ ) ∧ hd(csl0) '.last = hd(csl0) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl0), ⌜⌜al1⌝ ^.l⌝ , csl0.last) |
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cstartf(hd(csl0)) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl0), ⌜al1⌝ ^, csl0.last)
Used simplifier rules: ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ a '.last = a; (s) ⊦ a '[0] = a; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜[]⌝ = []; (s)
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cstartf(hd(csl0)) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl0), ⌜al1⌝ ^, csl0.last) |
csl0 = cs0 + csl, csl0 ≠ [], aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cstartf(cs0) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al1⌝ ^, csl0.last)
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl0, cs0, csl
| csl0 = cs0 + csl, csl0 ≠ [], aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2), cstartf(cs0) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al1⌝ ^, csl0.last) |
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al1⌝ ^, (cs0 ' + csl).last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a ' + x ≠ []; (s)
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al1⌝ ^, (cs0 ' + csl).last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cs0 = sl[0] ∧ (cs0 ' + csl).last = sl.last ∧ α ^ = ⌜al1⌝ ^) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used terms: (cs0 ' + csl).last, ⌜al1⌝ ^, cs0, cstepf, cstartf
| ⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cs0 = sl[0] ∧ (cs0 ' + csl).last = sl.last ∧ α ^ = ⌜al1⌝ ^) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ α, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ cs0 ≠ sl[0] ∨ (sl[0] ' + csl).last ≠ sl.last ∨ α ^ ≠ ⌜al1⌝ ^ ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used simplifier rules: ⊦ cfrag*(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ α, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ cs0 ≠ sl[0] ∨ (sl[0] ' + csl).last ≠ sl.last ∨ α ^ ≠ ⌜al1⌝ ^ ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a + x = a ' + x; (s) Used terms: ⌜al1⌝ , cs0 + csl
| aINV(as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜⌜al1⌝ ^.l⌝ , as) ∧ t(hd(csl0), as1) ∧ aINV(as1) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(hd(csl0), as1), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used simplifier rules: ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s)
| aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(hd(csl0), as1), t(csl0.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
csl0 = cs0 + csl, csl0 ≠ [], aINV(as), aINV(as1), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl0, cs0, csl
| csl0 = cs0 + csl, csl0 ≠ [], aINV(as), aINV(as1), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al1⌝ ), cstartf(csl0[0]), t(csl0.last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as2. t(csl0.last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, as1), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2)
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a ' + x ≠ []; (s)
| aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, as1), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as2. t((cs0 ' + csl).last, as2) ∧ aINV(as2) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as2) |
aINV(as), aINV(as1), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ t((cs0 ' + csl).last, as) ∧ aINV(as) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as)
Used terms: as
| aINV(as), aINV(as1), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ t((cs0 ' + csl).last, as) ∧ aINV(as) ∧ (∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as) |
aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, as1), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as
| aINV(as1), aINV(as), amove(AIOAut(astartf, astepf))(as1, ⌜al1⌝ ^, as), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, as1), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
aINV(as), aINV(as1), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al1⌝ ^ ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as
Used terms: as, ⌜al1⌝ ^, as1, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| aINV(as), aINV(as1), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, as), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al1⌝ ^ ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = as |
⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl[0]), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, asl[0]), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = asl.last
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl[0]), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, asl[0]), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ asl0, al2. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ) ∧ astartf(asl0[0]) ∧ asl0.last = asl.last |
⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl.last), aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, asl.last), t(cs0, asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = asl.last
Used terms: asl, al
| ⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl.last), aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t((cs0 ' + csl).last, asl.last), t(cs0, asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = asl.last |
⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl[0]), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, asl[0]), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦
| ⌜al⌝ ^ = ⌜al1⌝ ^, aINV(asl[0]), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al1⌝ ), cstartf(cs0), t(cs0, asl[0]), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ |
Used terms: cs0, asl[0]
| asl0.last = as2, aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ), astartf(asl0[0]), cstartf(cs3), t(cs3, asl0.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl0.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ |
aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ), astartf(asl0[0]), cstartf(cs3), t(cs3, asl0.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl0.last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦
| aINV(asl0.last), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al2⌝ ), astartf(asl0[0]), cstartf(cs3), t(cs3, asl0.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl0.last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ |
Used terms: cs3, asl0.last
| csl1.last = cs4, asl1.last = as3, aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4) |
aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)
| aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ csl2, al5, a2, cs6, as4. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) ∧ cstepf(csl2.last, a2, cs6) ∧ t(cs6, as4) ∧ aINV(as4) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a2 '⌝ ^, as4) ∧ t(csl2.last, as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4) |
aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)
Used terms: csl1, al3, a1, cs5, asl1.last
| aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ) ∧ cstartf(csl1[0]) ∧ cstepf(csl1.last, a1, cs5) ∧ t(cs5, asl1.last) ∧ aINV(asl1.last) → (∃ as. aINV(as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as)), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4) |
aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4)
| aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ as4. aINV(as4) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as4) ∧ amove(AIOAut(astartf, astepf))(as4, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as4) |
aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as)
Used terms: as
| aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ aINV(as) ∧ (∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as) ∧ amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last) ∧ t(csl1.last, as) |
aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
| aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as)
aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cexec(CIOAut(cstartf, cstepf))(⌜hd(csl1) '⌝ , ⌜[]⌝ ) ∧ hd(csl1) '.last = hd(csl1) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl1), ⌜⌜al3⌝ ^.l⌝ , csl1.last)
aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜⌜al3⌝ ^.l⌝ , as) ∧ t(hd(csl1), as1) ∧ aINV(as1) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used terms: cstartf, cstepf, astartf, astepf, t, aINV, hd(csl1) ', [], hd(csl1), ⌜al3⌝ ^.l, csl1.last, as
| weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), cexec(CIOAut(cstartf, cstepf))(⌜csl0⌝ , ⌜al0⌝ ), csl0.last = cs, cmove(CIOAut(cstartf, cstepf))(cs, ⌜al⌝ , cs0), t(cs0, as0), aINV(as0) ⊦ ∃ as. amove(AIOAut(astartf, astepf))(as, ⌜al⌝ , as0) ∧ t(cs, as) ∧ aINV(as) |
| aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cexec(CIOAut(cstartf, cstepf))(⌜hd(csl1) '⌝ , ⌜[]⌝ ) ∧ hd(csl1) '.last = hd(csl1) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl1), ⌜⌜al3⌝ ^.l⌝ , csl1.last) |
aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cstartf(hd(csl1)) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl1), ⌜al3⌝ ^, csl1.last)
Used simplifier rules: ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s) ⊦ a '.last = a; (s) ⊦ a '[0] = a; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ cfrag(CIOAut(startf, stepf))(⌜s '⌝ , []); (s) ⊦ cexec(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ startf(σ[0]); (s) ⊦ ⌜[]⌝ = []; (s)
| aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cstartf(hd(csl1)) ∧ cmove(CIOAut(cstartf, cstepf))(hd(csl1), ⌜al3⌝ ^, csl1.last) |
csl1 = cs0 + csl, csl1 ≠ [], aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cstartf(cs0) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al3⌝ ^, csl1.last)
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl1, cs0, csl0
| csl1 = cs0 + csl, csl1 ≠ [], aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as, cstartf(cs0) ∧ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al3⌝ ^, csl1.last) |
aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al3⌝ ^, (cs0 ' + csl).last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a ' + x ≠ []; (s)
| aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ cmove(CIOAut(cstartf, cstepf))(cs0, ⌜al3⌝ ^, (cs0 ' + csl).last), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cs0 = sl[0] ∧ (cs0 ' + csl).last = sl.last ∧ α ^ = ⌜al3⌝ ^) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used terms: (cs0 ' + csl).last, ⌜al3⌝ ^, cs0, cstepf, cstartf
| ⊦ cmove(CIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. cfrag*(CIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ α, sl. ¬(cfrag*(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∧ cs0 = sl[0] ∧ (cs0 ' + csl).last = sl.last ∧ α ^ = ⌜al3⌝ ^) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ α, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ cs0 ≠ sl[0] ∨ (sl[0] ' + csl).last ≠ sl.last ∨ α ^ ≠ ⌜al3⌝ ^ ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used simplifier rules: ⊦ cfrag*(CIOAut(startf, stepf))(σ, β) ↔ cfrag(CIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ α, sl. ¬ cfrag(CIOAut(cstartf, cstepf))(⌜sl⌝ , α) ∨ ¬ finp(α) ∨ cs0 ≠ sl[0] ∨ (sl[0] ' + csl).last ≠ sl.last ∨ α ^ ≠ ⌜al3⌝ ^ ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ (a ' + x)[0] = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ a + x = a ' + x; (s) Used terms: ⌜al3⌝ , cs0 + csl
| aINV(as), aINV(asl1.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ as1. amove(AIOAut(astartf, astepf))(as1, ⌜⌜al3⌝ ^.l⌝ , as) ∧ t(hd(csl1), as1) ∧ aINV(as1) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
aINV(as1), aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(hd(csl1), as1), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used simplifier rules: ⊦ ⌜⌜al⌝ ^.l⌝ = ⌜al⌝ ^; (s)
| aINV(as1), aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(hd(csl1), as1), t(cs5, asl1.last), t(csl1.last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
csl1 = cs0 + csl, csl1 ≠ [], aINV(as), aINV(asl1.last), aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ cfrag(CIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: csl1, cs0, csl0
| csl1 = cs0 + csl, csl1 ≠ [], aINV(as), aINV(asl1.last), aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜csl1⌝ , ⌜al3⌝ ), cstartf(csl1[0]), cstepf(csl1.last, a1, cs5), t(csl1.last, as), t(cs5, asl1.last), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
aINV(as1), aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, as1), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x)[0] = a; (s) ⊦ a ' + x ≠ []; (s)
| aINV(as1), aINV(asl1.last), aINV(as), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), amove(AIOAut(astartf, astepf))(as1, ⌜al3⌝ ^, as), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, as1), t(cs5, asl1.last), t((cs0 ' + csl).last, as), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
aINV(as), aINV(asl1.last), aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, as), t(cs5, asl1.last), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al3⌝ ^ ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as
Used terms: as, ⌜al3⌝ ^, as1, astepf, astartf
| ⊦ amove(AIOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. afrag*(AIOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| aINV(as), aINV(asl1.last), aINV(as1), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(as, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, as), t(cs5, asl1.last), t(cs0, as1), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∃ α, sl. afrag*(AIOAut(astartf, astepf))(⌜sl⌝ , α) ∧ as1 = sl[0] ∧ as = sl.last ∧ α ^ = ⌜al3⌝ ^ ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = as |
⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl[0]), aINV(asl1.last), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, asl[0]), t(cs5, asl1.last), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = asl.last
Used simplifier rules: ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream] ⊦ afrag*(AIOAut(startf, stepf))(σ, β) ↔ afrag(AIOAut(startf, stepf))(σ, β) ∧ finp(β); (s)
| ⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl[0]), aINV(asl1.last), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, asl[0]), t(cs5, asl1.last), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ ∃ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) ∧ asl2.last = asl.last |
⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl.last), aINV(asl1.last), aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, asl.last), t(cs5, asl1.last), t(cs0, asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = asl.last
Used terms: asl, al
| ⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl.last), aINV(asl1.last), aINV(asl[0]), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t((cs0 ' + csl).last, asl.last), t(cs5, asl1.last), t(cs0, asl[0]), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ astartf(asl[0]) ∧ asl.last = asl.last |
⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl[0]), aINV(asl1.last), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, asl[0]), t(cs5, asl1.last), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦
| ⌜al⌝ ^ = ⌜al3⌝ ^, aINV(asl[0]), aINV(asl1.last), aINV(asl.last), afrag(AIOAut(astartf, astepf))(⌜asl1⌝ , ⌜al4⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), amove(AIOAut(astartf, astepf))(asl.last, ⌜a1 '⌝ ^, asl1.last), astartf(asl1[0]), cfrag(CIOAut(cstartf, cstepf))(⌜cs0 '⌝ + ⌜csl⌝ , ⌜al3⌝ ), cstartf(cs0), cstepf((cs0 ' + csl).last, a1, cs5), t(cs0, asl[0]), t(cs5, asl1.last), t((cs0 ' + csl).last, asl.last), weakbwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), t, aINV), ¬ astartf(asl[0]), ∀ csl2, al5. cfrag(CIOAut(cstartf, cstepf))(⌜csl2⌝ , ⌜al5⌝ ) ∧ cstartf(csl2[0]) → (∃ as. t(csl2.last, as) ∧ aINV(as)), ∀ cs, as. cstartf(cs) ∧ t(cs, as) ∧ aINV(as) → astartf(as), ∀ asl2, al5. afrag(AIOAut(astartf, astepf))(⌜asl2⌝ , ⌜al5⌝ ) ∧ astartf(asl2[0]) → aINV(asl2.last) ⊦ |
Used terms: cs0, asl[0]
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.