Proof step 1 from proof step-absstep-CRASH-globalCRASH (conclusion) (back to tree)

System applied rule normalize

And obtained the following new goals

• Proof step 2:

  FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), abs(mkstate(gs, lsf, pcf), mkstate(ags, alsf, apcf)), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)) ⊦ ∃ ags0, alsf0, apcf0. flitpscStep(mkstate(ags, alsf, apcf), globalPSCCRASH, mkstate(ags0, alsf0, apcf0)) ∧ abs(mkstate(gs0, lsf0, pcf0), mkstate(ags0, alsf0, apcf0))

Rule argument

Additional information

Proof step 2 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 3:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ gs.pmem = gs0.pmem ∧ 0 = gs0.fctr(l) ∧ reorder(λ l. [], gs0.pq, gs0.rfo) ∧ ∅ = gs0.fwriters(l0) ∧ labs(gs0, lsf0(t), pcf0(t), mkFLITPSCgs(gs.pmem, λ l. [], λ l. 0, λ l. ∅, λ l. ∅), alsf(t), (apcf(t) = idle ⊃ idle;crashed))

Rule argument

Additional information

Used simplifier rules: abs-def: ⊦ abs(mkstate(gs, lsf, pcf), mkstate(ags, alsf, apcf)) ↔ gabs(gs, lsf, pcf, ags, alsf, apcf) ∧ (∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t))); gabs-def: ⊦ gabs(gs, lsf, pcf, ags, alsf, apcf) ↔ ags.mem = gs.pmem ∧ ags.ctr = gs.fctr ∧ reorder(ags.p, gs.pq, gs.rfo) ∧ ags.writers = gs.fwriters; ⊦ mkFLITPSCgs(mem, p, ctr, writers, writers0).writers = writers; (s) ⊦ mkFLITPSCgs(mem, p, ctr, writers, writers0).p = p; (s) ⊦ mkFLITPSCgs(mem, p, ctr, writers, writers0).ctr = ctr; (s) ⊦ mkFLITPSCgs(mem, p, ctr, writers, writers0).mem = mem; (s) ⊦ globalPSCCRASH ≠ globalPSCPERSIST_FO(l); (s) ⊦ globalPSCCRASH ≠ globalPSCPERSIST_W(l); (s) ⊦ ¬ pre(gs, ls, pc, globalPSCCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s) ⊦ flitpscStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ l. a = globalPSCPERSIST_W(l) ∧ firstPersistW(gs.p(l)) < # gs.p(l) ∧ gs0 = (gs.mem:= gs.mem(l := gs.p(l)[firstPersistW(gs.p(l))].val)) .p:= gs.p(l := gs.p(l) -p firstPersistW(gs.p(l))) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ l. a = globalPSCPERSIST_FO(l) ∧ (∃ n. isPersistFO(n, gs.p(l)) ∧ gs0 = gs.p:= gs.p(l := gs.p(l) -p n)) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalPSCCRASH ∧ gs0 = mkFLITPSCgs(gs.mem, λ l. [], λ l. 0, λ l. ∅, λ l. ∅) ∧ lsf0 = lsf ∧ pcf0 = (λ t. (pcf(t) = idle ⊃ idle;crashed)); (s)

Proof step 3 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic if-then-else split applied rule case distinction

And obtained the following new goals

• Proof step 4:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, gs.pmem ≠ gs0.pmem, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 14:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, 0 ≠ gs0.fctr(l), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 36:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 63:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, ∅ ≠ gs0.fwriters(l0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 88:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ¬ labs(gs0, lsf0(t), pcf0(t), mkFLITPSCgs(gs.pmem, λ l. [], λ l. 0, λ l. ∅, λ l. ∅), alsf(t), (apcf(t) = idle ⊃ idle;crashed)), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 4 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 5:

  ⊦ flitStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. a = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. a = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. a = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)

• Proof step 6:

  (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), globalCRASH, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. globalCRASH = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. globalCRASH = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. globalCRASH = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ globalCRASH = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, gs.pmem ≠ gs0.pmem, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used terms: pcf0, globalCRASH, lsf, gs0, pcf, lsf0, gs

Proof step 5 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 6 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 7:

  globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)) ∧ n < # gs.bq(t) ∧ isPropFO(n, l, gs.bq(t)) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, gs.pmem ≠ gs0.pmem, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ globalPERSIST_FO(loc); (s) ⊦ globalCRASH ≠ globalPERSIST_W(loc); (s) ⊦ globalCRASH ≠ propSF(t); (s) ⊦ doWrite(t, loc, v) ≠ globalCRASH; (s) ⊦ ¬ pre(gs, ls, pc, globalCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s)

Proof step 7 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic dl case distinction applied rule case distinction

And obtained the following new goals

• Proof step 8:

  ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs.pmem ≠ gs0.pmem, n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 11:

  ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, gs.pmem ≠ gs0.pmem, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 8 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 9:

  ⟨PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, gs.pmem ≠ gs0.pmem, n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 9 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 10:

  ⟨gs := ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ⟨PROP_FO(t, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, gs.pmem ≠ gs0.pmem, n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 10 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ (gs.rfo:= bq0).pmem = gs.pmem; (s) ⊦ (gs.bq:= bq).pmem = gs.pmem; (s) ⊦ (gs.pq:= pq).pmem = gs.pmem; (s)

Proof step 11 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 12:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, gs.pmem ≠ gs0.pmem, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 12 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 13:

  ⟨gs := (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf1), ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, gs.pmem ≠ gs0.pmem, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 13 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ (gs.rfo:= bq0).pmem = gs.pmem; (s) ⊦ (gs.freaders:= fwriters0).pmem = gs.pmem; (s) ⊦ (gs.fwriters:= fwriters).pmem = gs.pmem; (s) ⊦ (gs.bq:= bq).pmem = gs.pmem; (s) ⊦ (gs.fctr:= fctr).pmem = gs.pmem; (s) ⊦ (gs.pq:= pq).pmem = gs.pmem; (s)

Proof step 14 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 15:

  ⊦ flitStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. a = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. a = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. a = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)

• Proof step 16:

  (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), globalCRASH, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. globalCRASH = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. globalCRASH = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. globalCRASH = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ globalCRASH = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, 0 ≠ gs0.fctr(l), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used terms: pcf0, globalCRASH, lsf, gs0, pcf, lsf0, gs

Proof step 15 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 16 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 17:

  globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)) ∧ n < # gs.bq(t) ∧ isPropFO(n, l0, gs.bq(t)) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l0, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, 0 ≠ gs0.fctr(l), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ globalPERSIST_FO(loc); (s) ⊦ globalCRASH ≠ globalPERSIST_W(loc); (s) ⊦ globalCRASH ≠ propSF(t); (s) ⊦ doWrite(t, loc, v) ≠ globalCRASH; (s) ⊦ ¬ pre(gs, ls, pc, globalCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s)

Proof step 17 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic dl case distinction applied rule case distinction

And obtained the following new goals

• Proof step 18:

  ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l0, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), 0 ≠ gs0.fctr(l), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 30:

  ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, 0 ≠ gs0.fctr(l), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 18 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 19:

  ⟨PROP_FO(t, l0, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 19 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 20:

  ⟨gs := ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ⟨PROP_FO(t, l0, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 20 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 21:

  ⟨PROP_FO(t, l0, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), gs0 = ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf, pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 21 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 22:

  ⟨PROP_FO(t, l0, gs.fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), pq = gs.pq, rfo = gs.rfo, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l), n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ (gs.pq:= pq).fctr = gs.fctr; (s) ⊦ (gs.bq:= bq).fctr = gs.fctr; (s) ⊦ (gs.rfo:= bq0).fctr = gs.fctr; (s)

Proof step 22 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 23:

  ⟨choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), l = l0, pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: PROP_FO(tid, l, fwriters; pq, bq, rfo) {choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip };

Proof step 23 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule choose left

And obtained the following new goals

• Proof step 24:

  ⟨pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), l = l0, pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n0 < # gs.bq(t), n < # bq(tid), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l0, gs.bq(t)), isPropFO(n, l, bq(tid)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 27:

  ⟨skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), l = l0, pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))) ⊦

Rule argument

Additional information

Proof step 24 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 25:

  pq(l := pq(l) + FO(tid)) = pq0, bq(tid := bq(tid) -p n) = bq0, rfo(tid := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)) = rfo0, ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), l = l0, pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n < # bq(tid), n0 < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, bq(tid)), isPropFO(n0, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 25 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 26:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n0 < # gs.bq(t), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l0 := gs.pq(l0) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := (t ∈ gs.fwriters(l0) ⊃ gs.rfo(t);gs.rfo(t) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l0, gs.bq(t)), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s)

Proof step 26 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t, l0, gs.fwriters)

Proof step 27 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule skip left

And obtained the following new goals

• Proof step 28:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, bq = bq0, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), l = l0, pq = gs.pq, pq = pq0, rfo = gs.rfo, rfo = rfo0, tid = t, gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 28 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 29:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l0, gs.fwriters) ⊃ doWriteFO(t, l0);propFO(t, l0)), gs.bq(t) ≠ [], 0 ≠ gs.fctr(l1), n < # gs.bq(t), FLITInv(((gs.pq:= gs.pq).bq:= gs.bq).rfo:= gs.rfo, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l0, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n0. ¬ n0 < # gs.bq(t) ∨ ¬ isPropFO(n0, l0, gs.bq(t)) ⊦

Rule argument

Additional information

Proof step 29 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n

Proof step 30 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 31:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 31 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 32:

  ⟨gs := (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf1), ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 32 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 33:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, gs0 = (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf1, pq = gs.pq, rfo = gs.rfo, 0 ≠ gs0.fctr(l), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 33 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 34:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, 0 ≠ fctr0(l), FLITInv(gs, lsf, pcf), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ (gs.fctr:= fctr).fctr = fctr; (s) ⊦ (gs.bq:= bq).fctr = gs.fctr; (s) ⊦ (gs.fwriters:= fwriters).fctr = gs.fctr; (s) ⊦ (gs.freaders:= fwriters0).fctr = gs.fctr; (s) ⊦ (gs.rfo:= bq0).fctr = gs.fctr; (s)

Proof step 34 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 35:

  ⟨pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. []⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, 0 ≠ fctr0(l), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf) {pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. [] };

Proof step 35 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And closed the goal!

Rule argument

Additional information

Proof step 36 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 37:

  ⊦ flitStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. a = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. a = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. a = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)

• Proof step 38:

  (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), globalCRASH, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. globalCRASH = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. globalCRASH = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. globalCRASH = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ globalCRASH = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used terms: pcf0, globalCRASH, lsf, gs0, pcf, lsf0, gs

Proof step 37 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 38 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 39:

  globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)) ∧ n < # gs.bq(t) ∧ isPropFO(n, l, gs.bq(t)) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ globalPERSIST_FO(loc); (s) ⊦ globalCRASH ≠ globalPERSIST_W(loc); (s) ⊦ globalCRASH ≠ propSF(t); (s) ⊦ doWrite(t, loc, v) ≠ globalCRASH; (s) ⊦ ¬ pre(gs, ls, pc, globalCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s)

Proof step 39 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic dl case distinction applied rule case distinction

And obtained the following new goals

• Proof step 40:

  ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 54:

  ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 40 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 41:

  ⟨PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 41 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 42:

  ⟨gs := ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ⟨PROP_FO(t, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 42 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 43:

  ⟨PROP_FO(t, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs0 = ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf, pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 43 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 44:

  ⟨PROP_FO(t, l, gs.fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, gs.bq(t) ≠ [], n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ (gs.rfo:= bq0).rfo = bq0; (s) ⊦ (gs.pq:= pq).pq = pq; (s) ⊦ (gs.bq:= bq).pq = gs.pq; (s) ⊦ (gs.rfo:= bq0).pq = gs.pq; (s)

Proof step 44 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 45:

  ⟨choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: PROP_FO(tid, l, fwriters; pq, bq, rfo) {choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip };

Proof step 45 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule choose left

And obtained the following new goals

• Proof step 46:

  ⟨pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], n0 < # gs.bq(t), n < # bq(tid), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t)), isPropFO(n, l, bq(tid)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 51:

  ⟨skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))) ⊦

Rule argument

Additional information

Proof step 46 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 47:

  pq(l := pq(l) + FO(tid)) = pq0, bq(tid := bq(tid) -p n) = bq0, rfo(tid := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)) = rfo0, ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, gs.bq(t) ≠ [], n < # bq(tid), n0 < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, bq(tid)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 47 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 48:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs.bq(t) ≠ [], n0 < # gs.bq(t), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t)), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs.pq(l := gs.pq(l) + FO(t) '), gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s)

Proof step 48 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 49:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs.bq(t) ≠ [], n < # gs.bq(t), n0 < # gs.bq(t), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), t ∈ gs.fwriters(l), ¬ reorder(λ l. [], gs.pq(l := gs.pq(l) + FO(t) '), gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t ∈ gs.fwriters(l)

Proof step 49 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 50:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs.fwriters(l) ≠ 0, gs.bq(t) ≠ [], gs.fwriters(l) ≠ ∅, n < # gs.bq(t), n0 < # gs.bq(t), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := gs.rfo(t)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), t ∈ gs.fwriters(l), ¬ reorder(λ l. [], gs.pq(l := gs.pq(l) + FO(t) '), gs.rfo(t := gs.rfo(t))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 50 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t, l, gs.fwriters)

Proof step 51 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule skip left

And obtained the following new goals

• Proof step 52:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, bq = bq0, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, pq = pq0, rfo = gs.rfo, rfo = rfo0, tid = t, gs.bq(t) ≠ [], n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 52 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 53:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs.bq(t) ≠ [], n < # gs.bq(t), FLITInv(((gs.pq:= gs.pq).bq:= gs.bq).rfo:= gs.rfo, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n0. ¬ n0 < # gs.bq(t) ∨ ¬ isPropFO(n0, l, gs.bq(t)) ⊦

Rule argument

Additional information

Proof step 53 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n

Proof step 54 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 55:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 55 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 56:

  ⟨gs := (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf1), ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 56 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 57:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, gs0 = (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf1, pq = gs.pq, rfo = gs.rfo, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], gs0.pq, gs0.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 57 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 58:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ (gs.rfo:= bq0).rfo = bq0; (s) ⊦ (gs.pq:= pq).pq = pq; (s) ⊦ (gs.fctr:= fctr).pq = gs.pq; (s) ⊦ (gs.bq:= bq).pq = gs.pq; (s) ⊦ (gs.fwriters:= fwriters).pq = gs.pq; (s) ⊦ (gs.freaders:= fwriters0).pq = gs.pq; (s) ⊦ (gs.rfo:= bq0).pq = gs.pq; (s)

Proof step 58 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 59:

  ⟨pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. []⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf) {pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. [] };

Proof step 59 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 60:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, (λ l. []) = pq0, (λ l. 0) = fctr0, (λ t. []) = bq0, (λ l. ∅) = fwriters0, (λ l. ∅) = freaders0, (λ t. []) = rfo0, (λ t. (pcf(t) = idle ⊃ idle;crashed)) = pcf1, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], pq0, rfo0), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 60 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 61:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv ((((((gs.pq:= (λ l. [])).fctr:= (λ l. 0)).bq:= (λ t. [])).fwriters:= (λ l. ∅)).freaders:= (λ l. ∅)).rfo:= (λ t. []), lsf, λ t. (pcf(t) = idle ⊃ idle;crashed)), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ¬ reorder(λ l. [], λ l. [], λ t. []), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 61 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 62:

  ⊦ reorder(p, pq, rfo) ↔ (∀ l. reorder(l, p(l), pq(l), rfo))

Rule argument

Additional information

Used simplifier rules: ⊦ reorder(l, [], fowl0, rfo) ↔ fowl0 = [] ∧ (∀ t. propFOs(t, l, rfo(t)) = []); (s) ⊦ propFOs(t, l, []) = []; (s) Used terms: λ l. [], λ l. [], λ t. []

Proof step 62 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 63 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 64:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero: ⊦ # s ≠ 0 → s ≠ ∅; (forward) from specification set-basic size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic

Proof step 64 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 65:

  ⊦ flitStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. a = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. a = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. a = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)

• Proof step 66:

  (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), globalCRASH, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. globalCRASH = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. globalCRASH = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. globalCRASH = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ globalCRASH = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used terms: pcf0, globalCRASH, lsf, gs0, pcf, lsf0, gs

Proof step 65 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 66 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 67:

  globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)) ∧ n < # gs.bq(t) ∧ isPropFO(n, l, gs.bq(t)) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ globalPERSIST_FO(loc); (s) ⊦ globalCRASH ≠ globalPERSIST_W(loc); (s) ⊦ globalCRASH ≠ propSF(t); (s) ⊦ doWrite(t, loc, v) ≠ globalCRASH; (s) ⊦ ¬ pre(gs, ls, pc, globalCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s)

Proof step 67 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic dl case distinction applied rule case distinction

And obtained the following new goals

• Proof step 68:

  ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 82:

  ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 68 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 69:

  ⟨PROP_FO(t, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 69 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 70:

  ⟨gs := ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ⟨PROP_FO(t, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 70 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 71:

  ⟨PROP_FO(t, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), gs0 = ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf, pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), n < # gs.bq(t), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 71 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 72:

  ⟨PROP_FO(t, l, gs.fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) size-zero: ⊦ # s ≠ 0 → s ≠ ∅; (forward) from specification set-basic size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ (gs.pq:= pq).fwriters = gs.fwriters; (s) ⊦ (gs.bq:= bq).fwriters = gs.fwriters; (s) ⊦ (gs.rfo:= bq0).fwriters = gs.fwriters; (s)

Proof step 72 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 73:

  ⟨choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: PROP_FO(tid, l, fwriters; pq, bq, rfo) {choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip };

Proof step 73 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule choose left

And obtained the following new goals

• Proof step 74:

  ⟨pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n0 < # gs.bq(t), n < # bq(tid), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t)), isPropFO(n, l, bq(tid)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 79:

  ⟨skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))) ⊦

Rule argument

Additional information

Proof step 74 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 75:

  pq(l := pq(l) + FO(tid)) = pq0, bq(tid := bq(tid) -p n) = bq0, rfo(tid := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)) = rfo0, ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, rfo = gs.rfo, tid = t, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # bq(tid), n0 < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, bq(tid)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 75 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 76:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n0 < # gs.bq(t), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t)), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s)

Proof step 76 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 77:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), n0 < # gs.bq(t), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := (t ∈ gs.fwriters(l) ⊃ gs.rfo(t);gs.rfo(t) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), t ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t ∈ gs.fwriters(l)

Proof step 77 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 78:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs.fwriters(l0) ≠ 0, # gs.fwriters(l) ≠ 0, gs.bq(t) ≠ [], gs.fwriters(l) ≠ ∅, ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), n0 < # gs.bq(t), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t) ')).bq:= gs.bq(t := gs.bq(t) -p n)).rfo:= gs.rfo(t := gs.rfo(t)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), isPropFO(n0, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), t ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 78 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t, l, gs.fwriters)

Proof step 79 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule skip left

And obtained the following new goals

• Proof step 80:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, bq = bq0, fwriters = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), pq = gs.pq, pq = pq0, rfo = gs.rfo, rfo = rfo0, tid = t, # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 80 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 81:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t, l, gs.fwriters) ⊃ doWriteFO(t, l);propFO(t, l)), # gs.fwriters(l0) ≠ 0, gs.bq(t) ≠ [], ∅ ≠ gs.fwriters(l0), n < # gs.bq(t), FLITInv(((gs.pq:= gs.pq).bq:= gs.bq).rfo:= gs.rfo, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n0. ¬ n0 < # gs.bq(t) ∨ ¬ isPropFO(n0, l, gs.bq(t)) ⊦

Rule argument

Additional information

Proof step 81 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n

Proof step 82 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 83:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 83 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 84:

  ⟨gs := (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf1), ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 84 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 85:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, gs0 = (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf1, pq = gs.pq, rfo = gs.rfo, # gs0.fwriters(l0) ≠ 0, ∅ ≠ gs0.fwriters(l0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Proof step 85 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 86:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, # fwriters0(l0) ≠ 0, ∅ ≠ fwriters0(l0), FLITInv(gs, lsf, pcf), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero: ⊦ # s ≠ 0 → s ≠ ∅; (forward) from specification set-basic size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ⊦ (gs.fwriters:= fwriters).fwriters = fwriters; (s) ⊦ (gs.freaders:= fwriters0).fwriters = gs.fwriters; (s) ⊦ (gs.rfo:= bq0).fwriters = gs.fwriters; (s)

Proof step 86 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 87:

  ⟨pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. []⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, # fwriters0(l0) ≠ 0, ∅ ≠ fwriters0(l0), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: decl: CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf) {pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. [] };

Proof step 87 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And closed the goal!

Rule argument

Additional information

Proof step 88 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 89:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), flitStep(mkstate(gs, lsf, pcf), globalCRASH, mkstate(gs0, lsf0, pcf0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: labs-def: ⊦ labs(gs, ls, pc, ags, als, apc) ↔ ls.t = als.t ∧ (pc = idle → apc = idle) ∧ (pc = ready → apc = ready) ∧ (pc = crashed → apc = crashed) ∧ (pc = R1 → apc = R1) ∧ (pc = R2 → apc = R2) ∧ (pc = R3 → apc = R3) ∧ (pc = R4 → apc = R4) ∧ (pc = R1 ∨ pc = R2 ∨ pc = R3 ∨ pc = R4 → ls.loc = als.l) ∧ (pc = R2 ∨ pc = R3 ∨ pc = R4 → ls.val = als.v) ∧ (pc = W1 → apc = W1) ∧ (pc = W2 → apc = (SF ∈ gs.bq(ls.t) ⊃ W1;W2)) ∧ (pc = W3 → apc = W3) ∧ (pc = W4 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3;W4)) ∧ ( pc = W5 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3;(FO(ls.loc) ∈ gs.bq(ls.t) ⊃ W4;W5))) ∧ ( pc = W6 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3 ;(FO(ls.loc) ∈ gs.bq(ls.t) ⊃ W4;(SF ∈ gs.bq(ls.t) ⊃ W5;W6)) )) ∧ (pc = W7 → apc = W7) ∧ ( pc = W1 ∨ pc = W2 ∨ pc = W3 ∨ pc = W4 ∨ pc = W5 ∨ pc = W6 ∨ pc = W7 → ls.loc = als.l) ∧ ( pc = W1 ∨ pc = W2 ∨ pc = W3 ∨ pc = W4 ∨ pc = W5 ∨ pc = W6 ∨ pc = W7 → ls.val = als.v); ⊦ W7 ≠ crashed; (s) ⊦ W7 ≠ idle; (s) ⊦ W3 ≠ crashed; (s) ⊦ W3 ≠ idle; (s) ⊦ W1 ≠ crashed; (s) ⊦ W1 ≠ idle; (s) ⊦ R4 ≠ crashed; (s) ⊦ R4 ≠ idle; (s) ⊦ R3 ≠ crashed; (s) ⊦ R3 ≠ idle; (s) ⊦ R2 ≠ crashed; (s) ⊦ R2 ≠ idle; (s) ⊦ R1 ≠ crashed; (s) ⊦ R1 ≠ idle; (s) ⊦ crashed ≠ idle; (s) ⊦ crashed ≠ ready; (s) ⊦ idle ≠ ready; (s)

Proof step 89 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 90:

  ⊦ flitStep(mkstate(gs, lsf, pcf), a, mkstate(gs0, lsf0, pcf0)) ↔ (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), a, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. a = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. a = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. a = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. a = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ a = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)

• Proof step 91:

  (∃ t, ls, pc. lstep(gs, lsf(t), pcf(t), globalCRASH, gs0, ls, pc) ∧ lsf0 = lsf(t := ls) ∧ pcf0 = pcf(t := pc)) ∨ (∃ tid. globalCRASH = doWrite(tid, gs.bq(tid).head.l, gs.bq(tid).head.v) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head.W?) ∧ gs0 = (gs.pq:= gs.pq(gs.bq(tid).head.l := gs.pq(gs.bq(tid).head.l) + W(gs.bq(tid).head.v, tid))).bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ tid, l. globalCRASH = (oneMember(tid, l, gs.fwriters) ⊃ doWriteFO(tid, l);propFO(tid, l)) ∧ (∃ n. n < # gs.bq(tid) ∧ isPropFO(n, l, gs.bq(tid))) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(tid, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf)) ∨ (∃ tid. globalCRASH = propSF(tid) ∧ (gs.bq(tid) ≠ [] ∧ gs.bq(tid).head = SF ∧ (∀ l. ¬ FO(tid) ∈ gs.pq(l))) ∧ gs0 = gs.bq:= gs.bq(tid := gs.bq(tid).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_W(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.W?) ∧ gs0 = (gs.pmem:= gs.pmem(loc := gs.pq(loc).head.val)).pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ (∃ loc. globalCRASH = globalPERSIST_FO(loc) ∧ (gs.pq(loc) ≠ [] ∧ gs.pq(loc).head.FO?) ∧ gs0 = gs.pq:= gs.pq(loc := gs.pq(loc).tail) ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ globalCRASH = globalCRASH ∧ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Used terms: pcf0, globalCRASH, lsf, gs0, pcf, lsf0, gs

Proof step 90 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

A spec-lemma

Proof step 91 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 92:

  globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)) ∧ n < # gs.bq(t0) ∧ isPropFO(n, l, gs.bq(t0)) ∧ ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t0, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf) ∨ ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ globalPERSIST_FO(loc); (s) ⊦ globalCRASH ≠ globalPERSIST_W(loc); (s) ⊦ globalCRASH ≠ propSF(t); (s) ⊦ doWrite(t, loc, v) ≠ globalCRASH; (s) ⊦ ¬ pre(gs, ls, pc, globalCRASH); (s) ⊦ lstep(gs, ls, pc, a, gs0, ls0, pc0) ↔ pre(gs, ls, pc, a) ∧ ls0 = lstepf(gs, ls, pc, a) ∧ gs0 = gstepf(gs, ls, pc, a) ∧ pc0 = pcstepf(gs, ls, pc, a); (s)

Proof step 92 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic dl case distinction applied rule case distinction

And obtained the following new goals

• Proof step 93:

  ⟨fwriters := gs.fwriters, pq := gs.pq, bq := gs.bq, rfo := gs.rfo; PROP_FO(t0, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), n < # gs.bq(t0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

• Proof step 156:

  ⟨pq := gs.pq, fctr := gs.fctr, bq := gs.bq, fwriters := gs.fwriters, freaders := gs.freaders, rfo := gs.rfo; CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 93 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 94:

  ⟨PROP_FO(t0, l, fwriters; pq, bq, rfo); gs := ((gs.pq:= pq).bq:= bq).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 94 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 95:

  ⟨gs := ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ⟨PROP_FO(t0, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t0), FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 95 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 96:

  ⟨PROP_FO(t0, l, fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs0 = ((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf, pq = gs.pq, rfo = gs.rfo, n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 96 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 97:

  ⟨PROP_FO(t0, l, gs.fwriters; pq, bq, rfo)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, gs.bq(t0) ≠ [], n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ (gs.bq:= bq).bq = bq; (s) ⊦ (gs.rfo:= bq0).bq = gs.bq; (s)

Proof step 97 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 98:

  ⟨choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, tid = t0, gs.bq(t0) ≠ [], n < # gs.bq(t0), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: decl: PROP_FO(tid, l, fwriters; pq, bq, rfo) {choose n with n < # bq(tid) ∧ isPropFO(n, l, bq(tid)) in pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n) ifnone skip };

Proof step 98 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule choose left

And obtained the following new goals

• Proof step 99:

  ⟨pq(l) := pq(l) + FO(tid), bq(tid) := bq(tid) -p n, rfo(tid) := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, tid = t0, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # bq(tid), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, bq(tid)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

• Proof step 153:

  ⟨skip⟩ (pq = pq0 ∧ bq = bq0 ∧ rfo = rfo0), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, tid = t0, gs.bq(t0) ≠ [], n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 99 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 100:

  pq(l := pq(l) + FO(tid)) = pq0, bq(tid := bq(tid) -p n) = bq0, rfo(tid := (tid ∈ fwriters(l) ⊃ rfo(tid);rfo(tid) -p n)) = rfo0, ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, rfo = gs.rfo, tid = t0, gs.bq(t0) ≠ [], n < # bq(tid), n0 < # gs.bq(t0), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, bq(tid)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 100 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 101:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3;W4)) ∧ ( pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4;W5) )) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4 ;(SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W5;W6) ) )) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: ⊦ x + a = x + a '; (s)

Proof step 101 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic if-then-else split applied rule case distinction

And obtained the following new goals

• Proof step 102:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).t ≠ alsf(t).t, n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 105:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = idle, gs.bq(t0) ≠ [], apcf(t) ≠ idle, n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 108:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = ready, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 111:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, apcf(t) = idle, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = crashed, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 114:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R1, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 117:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R2, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 120:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R3, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 123:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R4, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 126:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W1, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 129:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W2, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W1;W2), n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 132:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W3, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 135:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W4, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3;W4), n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 138:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W5, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4;W5) ), n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 141:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W6, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4 ;(SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W5;W6) ) ), n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 144:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W7, gs.bq(t0) ≠ [], n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

• Proof step 147:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).loc ≠ alsf(t).l, n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

• Proof step 150:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).val ≠ alsf(t).v, n < # gs.bq(t0), n0 < # gs.bq(t0), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), isPropFO(n0, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

Rule argument

Additional information

Proof step 102 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 103:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).t ≠ alsf(t).t, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 103 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 104:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, lsf(t).t ≠ alsf(t).t, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 104 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 105 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 106:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = idle, gs.bq(t0) ≠ [], apcf(t) ≠ idle, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 106 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 107:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = idle, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, apcf(t) ≠ idle, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 107 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 108 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 109:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = ready, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 109 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 110:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = ready, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 110 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 111 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 112:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, apcf(t) = idle, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = crashed, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 112 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 113:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, apcf(t) = idle, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = crashed, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 113 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 114 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 115:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R1, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 115 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 116:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R1, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 116 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 117 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 118:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R2, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 118 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 119:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R2, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 119 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 120 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 121:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R3, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 121 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 122:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R3, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 122 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 123 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 124:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R4, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 124 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 125:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = R4, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 125 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 126 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 127:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W1, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 127 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 128:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W1, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 128 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 129 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 130:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W2, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W1;W2), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 130 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 131:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W2, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, (apcf(t) = idle ⊃ idle;crashed) ≠ (SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W1;W2), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 131 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 132 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 133:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W3, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 133 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 134:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W3, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 134 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 135 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 136:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W4, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3;W4), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 136 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 137:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W4, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3;W4), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 137 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 138 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 139:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W5, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4;W5) ), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 139 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 140:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W5, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4;W5) ), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 140 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 141 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 142:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W6, gs.bq(t0) ≠ [], (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4 ;(SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W5;W6) ) ), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 142 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 143:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W6, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, (apcf(t) = idle ⊃ idle;crashed) ≠ (W(lsf(t).loc, lsf(t).val) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W3 ;(FO(lsf(t).loc) ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W4 ;(SF ∈ (t0 = lsf(t).t ⊃ gs.bq(lsf(t).t) -p n;gs.bq(lsf(t).t)) ⊃ W5;W6) ) ), n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 143 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 144 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 145:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W7, gs.bq(t0) ≠ [], n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 145 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 146:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pcf(t) = W7, # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 146 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 147 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 148:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).loc ≠ alsf(t).l, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 148 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 149:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, lsf(t).loc ≠ alsf(t).l, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 149 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 150 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 151:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], lsf(t).val ≠ alsf(t).v, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv (((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := (t0 ∈ gs.fwriters(l) ⊃ gs.rfo(t0);gs.rfo(t0) -p n)), lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ oneMember(t, l, tsf) → (t ∈ tsf(l0) ↔ l = l0); (s) ⊦ globalCRASH ≠ propFO(t, loc); (s) Used formulas: t0 ∈ gs.fwriters(l)

Proof step 151 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 152:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), # gs.fwriters(l) ≠ 0, gs.bq(t0) ≠ [], gs.fwriters(l) ≠ ∅, lsf(t).val ≠ alsf(t).v, n0 < # gs.bq(t0), n < # gs.bq(t0), FLITInv(((gs.pq:= gs.pq(l := gs.pq(l) + FO(t0) ')).bq:= gs.bq(t0 := gs.bq(t0) -p n)).rfo:= gs.rfo(t0 := gs.rfo(t0)), lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n0, l, gs.bq(t0)), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), t0 ∈ gs.fwriters(l), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 ⊦

Rule argument

Additional information

Used simplifier rules: size-zero-01: ⊦ s ≠ ∅ → # s ≠ 0; (forward) from specification set-basic ne-01: ⊦ a ∈ s → s ≠ ∅; (forward) from specification set-basic

Proof step 152 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ globalCRASH ≠ propFO(t, loc); (s) ⊦ doWriteFO(t, loc) ≠ globalCRASH; (s) Used formulas: oneMember(t0, l, gs.fwriters)

Proof step 153 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule skip left

And obtained the following new goals

• Proof step 154:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, bq = bq0, fwriters = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), pq = gs.pq, pq = pq0, rfo = gs.rfo, rfo = rfo0, tid = t0, gs.bq(t0) ≠ [], n < # gs.bq(t0), FLITInv(((gs.pq:= pq0).bq:= bq0).rfo:= rfo0, lsf, pcf), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ n. ¬(n < # bq(tid) ∧ isPropFO(n, l, bq(tid))), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 154 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 155:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, globalCRASH = (oneMember(t0, l, gs.fwriters) ⊃ doWriteFO(t0, l);propFO(t0, l)), gs.bq(t0) ≠ [], n < # gs.bq(t0), FLITInv(gs, lsf, pcf), FLITInv(((gs.pq:= gs.pq).bq:= gs.bq).rfo:= gs.rfo, lsf, pcf), FLITPSCInv(ags, alsf, apcf), isPropFO(n, l, gs.bq(t0)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), ∀ n0. ¬ n0 < # gs.bq(t0) ∨ ¬ isPropFO(n0, l, gs.bq(t0)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ pcf(t) ≠ ready ∧ (pcf(t) = crashed → apcf(t) ≠ idle) ∧ pcf(t) ≠ R1 ∧ pcf(t) ≠ R2 ∧ pcf(t) ≠ R3 ∧ pcf(t) ≠ R4 ∧ pcf(t) ≠ W1 ∧ (pcf(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs.bq(lsf(t).t) ⊃ W1;W2)) ∧ pcf(t) ≠ W3 ∧ (pcf(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ gs.bq(lsf(t).t) ⊃ W3;W4)) ∧ (pcf(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ gs.bq(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ gs.bq(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ gs.bq(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ gs.bq(lsf(t).t) ⊃ W4;(SF ∈ gs.bq(lsf(t).t) ⊃ W5;W6)))) ∧ pcf(t) ≠ W7 ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf(t) = W2 ∨ pcf(t) = W4 ∨ pcf(t) = W5 ∨ pcf(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 155 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n

Proof step 156 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 157:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf); gs := (((((gs.pq:= pq).fctr:= fctr).bq:= bq).fwriters:= fwriters).freaders:= freaders).rfo:= rfo⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 157 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic split applied rule split left

And obtained the following new goals

• Proof step 158:

  ⟨gs := (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0⟩ (gs0 = gs ∧ lsf0 = lsf ∧ pcf0 = pcf1), ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs0, lsf0, pcf0), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 158 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 159:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, gs0 = (((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf0 = lsf, pcf0 = pcf1, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv(gs0, lsf0, pcf0), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf0(t).t = alsf(t).t ∧ (pcf0(t) = idle → apcf(t) = idle) ∧ pcf0(t) ≠ ready ∧ (pcf0(t) = crashed → apcf(t) ≠ idle) ∧ pcf0(t) ≠ R1 ∧ pcf0(t) ≠ R2 ∧ pcf0(t) ≠ R3 ∧ pcf0(t) ≠ R4 ∧ pcf0(t) ≠ W1 ∧ (pcf0(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ gs0.bq(lsf0(t).t) ⊃ W1;W2)) ∧ pcf0(t) ≠ W3 ∧ (pcf0(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;W4)) ∧ ( pcf0(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;W5))) ∧ ( pcf0(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf0(t).loc, lsf0(t).val) ∈ gs0.bq(lsf0(t).t) ⊃ W3;(FO(lsf0(t).loc) ∈ gs0.bq(lsf0(t).t) ⊃ W4;(SF ∈ gs0.bq(lsf0(t).t) ⊃ W5;W6)))) ∧ pcf0(t) ≠ W7 ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).loc = alsf(t).l) ∧ (pcf0(t) = W2 ∨ pcf0(t) = W4 ∨ pcf0(t) = W5 ∨ pcf0(t) = W6 → lsf0(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 159 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 160:

  ⟨CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf)⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf1(t) = idle → apcf(t) = idle) ∧ pcf1(t) ≠ ready ∧ (pcf1(t) = crashed → apcf(t) ≠ idle) ∧ pcf1(t) ≠ R1 ∧ pcf1(t) ≠ R2 ∧ pcf1(t) ≠ R3 ∧ pcf1(t) ≠ R4 ∧ pcf1(t) ≠ W1 ∧ (pcf1(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf1(t) ≠ W3 ∧ (pcf1(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf1(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf1(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf1(t) ≠ W7 ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: ⊦ (gs.bq:= bq).bq = bq; (s) ⊦ (gs.fwriters:= fwriters).bq = gs.bq; (s) ⊦ (gs.freaders:= fwriters0).bq = gs.bq; (s) ⊦ (gs.rfo:= bq0).bq = gs.bq; (s)

Proof step 160 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic unfold applied rule call left

And obtained the following new goals

• Proof step 161:

  ⟨pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. []⟩ (pq = pq0 ∧ fctr = fctr0 ∧ bq = bq0 ∧ fwriters = fwriters0 ∧ freaders = freaders0 ∧ rfo = rfo0 ∧ pcf = pcf1), ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv(gs, lsf, pcf), FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf1(t) = idle → apcf(t) = idle) ∧ pcf1(t) ≠ ready ∧ (pcf1(t) = crashed → apcf(t) ≠ idle) ∧ pcf1(t) ≠ R1 ∧ pcf1(t) ≠ R2 ∧ pcf1(t) ≠ R3 ∧ pcf1(t) ≠ R4 ∧ pcf1(t) ≠ W1 ∧ (pcf1(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf1(t) ≠ W3 ∧ (pcf1(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf1(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf1(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf1(t) ≠ W7 ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Used simplifier rules: decl: CRASH(; pq, fctr, bq, fwriters, freaders, rfo, pcf) {pcf := λ t. (pcf(t) = idle ⊃ idle;crashed), pq := λ l. [], fctr := λ l. 0, freaders := λ l. ∅, fwriters := λ l. ∅, bq := λ t. [], rfo := λ t. [] };

Proof step 161 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic symbolic execution applied rule assign left

And obtained the following new goals

• Proof step 162:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, (λ l. []) = pq0, (λ l. 0) = fctr0, (λ t. []) = bq0, (λ l. ∅) = fwriters0, (λ l. ∅) = freaders0, (λ t. []) = rfo0, (λ t. (pcf(t) = idle ⊃ idle;crashed)) = pcf1, bq = gs.bq, fctr = gs.fctr, freaders = gs.freaders, fwriters = gs.fwriters, pq = gs.pq, rfo = gs.rfo, FLITInv((((((gs.pq:= pq0).fctr:= fctr0).bq:= bq0).fwriters:= fwriters0).freaders:= freaders0).rfo:= rfo0, lsf, pcf1), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf1(t) = idle → apcf(t) = idle) ∧ pcf1(t) ≠ ready ∧ (pcf1(t) = crashed → apcf(t) ≠ idle) ∧ pcf1(t) ≠ R1 ∧ pcf1(t) ≠ R2 ∧ pcf1(t) ≠ R3 ∧ pcf1(t) ≠ R4 ∧ pcf1(t) ≠ W1 ∧ (pcf1(t) = W2 → (apcf(t) = idle ⊃ idle;crashed) = (SF ∈ bq0(lsf(t).t) ⊃ W1;W2)) ∧ pcf1(t) ≠ W3 ∧ (pcf1(t) = W4 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;W4)) ∧ (pcf1(t) = W5 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;W5))) ∧ ( pcf1(t) = W6 → (apcf(t) = idle ⊃ idle;crashed) = (W(lsf(t).loc, lsf(t).val) ∈ bq0(lsf(t).t) ⊃ W3;(FO(lsf(t).loc) ∈ bq0(lsf(t).t) ⊃ W4;(SF ∈ bq0(lsf(t).t) ⊃ W5;W6)))) ∧ pcf1(t) ≠ W7 ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).loc = alsf(t).l) ∧ (pcf1(t) = W2 ∨ pcf1(t) = W4 ∨ pcf1(t) = W5 ∨ pcf1(t) = W6 → lsf(t).val = alsf(t).v)

Rule argument

Additional information

Proof step 162 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 163:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv(gs, lsf, pcf), FLITInv ((((((gs.pq:= (λ l. [])).fctr:= (λ l. 0)).bq:= (λ t. [])).fwriters:= (λ l. ∅)).freaders:= (λ l. ∅)).rfo:= (λ t. []), lsf, λ t. (pcf(t) = idle ⊃ idle;crashed)), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ (pcf(t) ≠ idle → apcf(t) ≠ idle)

Rule argument

Additional information

Used simplifier rules: ⊦ W6 ≠ crashed; (s) ⊦ W6 ≠ idle; (s) ⊦ W5 ≠ crashed; (s) ⊦ W5 ≠ idle; (s) ⊦ W4 ≠ crashed; (s) ⊦ W4 ≠ idle; (s) ⊦ W2 ≠ crashed; (s) ⊦ W2 ≠ idle; (s) ⊦ W7 ≠ crashed; (s) ⊦ W7 ≠ idle; (s) ⊦ W3 ≠ crashed; (s) ⊦ W3 ≠ idle; (s) ⊦ W1 ≠ crashed; (s) ⊦ W1 ≠ idle; (s) ⊦ R4 ≠ crashed; (s) ⊦ R4 ≠ idle; (s) ⊦ R3 ≠ crashed; (s) ⊦ R3 ≠ idle; (s) ⊦ R2 ≠ crashed; (s) ⊦ R2 ≠ idle; (s) ⊦ R1 ≠ crashed; (s) ⊦ R1 ≠ idle; (s) ⊦ crashed ≠ idle; (s) ⊦ crashed ≠ ready; (s) ⊦ idle ≠ ready; (s)

Proof step 163 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 164:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, ags.writers = gs.fwriters, FLITInv ((((((gs.pq:= (λ l. [])).fctr:= (λ l. 0)).bq:= (λ t. [])).fwriters:= (λ l. ∅)).freaders:= (λ l. ∅)).rfo:= (λ t. []), lsf, λ t. (pcf(t) = idle ⊃ idle;crashed)), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦ lsf(t).t = alsf(t).t ∧ (pcf(t) = idle → apcf(t) = idle) ∧ (pcf(t) ≠ idle → apcf(t) ≠ idle)

Rule argument

Additional information

Used terms: t

Proof step 164 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 165:

  ags.ctr = gs.fctr, ags.mem = gs.pmem, lsf(t).t = alsf(t).t, ags.writers = gs.fwriters, apcf(t) = idle, pcf(t) ≠ idle, pcf(t) ≠ W7, pcf(t) ≠ W6, pcf(t) ≠ W5, pcf(t) ≠ W4, pcf(t) ≠ W3, pcf(t) ≠ W2, pcf(t) ≠ W1, pcf(t) ≠ R4, pcf(t) ≠ R3, pcf(t) ≠ R2, pcf(t) ≠ R1, pcf(t) ≠ crashed, pcf(t) ≠ ready, FLITInv ((((((gs.pq:= (λ l. [])).fctr:= (λ l. 0)).bq:= (λ t. [])).fwriters:= (λ l. ∅)).freaders:= (λ l. ∅)).rfo:= (λ t. []), lsf, λ t. (pcf(t) = idle ⊃ idle;crashed)), FLITInv(gs, lsf, pcf), FLITPSCInv(ags, alsf, apcf), reorder(ags.p, gs.pq, gs.rfo), ∀ t. labs(gs, lsf(t), pcf(t), ags, alsf(t), apcf(t)) ⊦

Rule argument

Additional information

Used simplifier rules: labs-def: ⊦ labs(gs, ls, pc, ags, als, apc) ↔ ls.t = als.t ∧ (pc = idle → apc = idle) ∧ (pc = ready → apc = ready) ∧ (pc = crashed → apc = crashed) ∧ (pc = R1 → apc = R1) ∧ (pc = R2 → apc = R2) ∧ (pc = R3 → apc = R3) ∧ (pc = R4 → apc = R4) ∧ (pc = R1 ∨ pc = R2 ∨ pc = R3 ∨ pc = R4 → ls.loc = als.l) ∧ (pc = R2 ∨ pc = R3 ∨ pc = R4 → ls.val = als.v) ∧ (pc = W1 → apc = W1) ∧ (pc = W2 → apc = (SF ∈ gs.bq(ls.t) ⊃ W1;W2)) ∧ (pc = W3 → apc = W3) ∧ (pc = W4 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3;W4)) ∧ ( pc = W5 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3;(FO(ls.loc) ∈ gs.bq(ls.t) ⊃ W4;W5))) ∧ ( pc = W6 → apc = (W(ls.loc, ls.val) ∈ gs.bq(ls.t) ⊃ W3 ;(FO(ls.loc) ∈ gs.bq(ls.t) ⊃ W4;(SF ∈ gs.bq(ls.t) ⊃ W5;W6)) )) ∧ (pc = W7 → apc = W7) ∧ ( pc = W1 ∨ pc = W2 ∨ pc = W3 ∨ pc = W4 ∨ pc = W5 ∨ pc = W6 ∨ pc = W7 → ls.loc = als.l) ∧ ( pc = W1 ∨ pc = W2 ∨ pc = W3 ∨ pc = W4 ∨ pc = W5 ∨ pc = W6 ∨ pc = W7 → ls.val = als.v); ⊦ idle ≠ ready; (s) ⊦ crashed ≠ idle; (s) ⊦ R1 ≠ idle; (s) ⊦ R2 ≠ idle; (s) ⊦ R3 ≠ idle; (s) ⊦ R4 ≠ idle; (s) ⊦ W1 ≠ idle; (s) ⊦ W2 ≠ idle; (s) ⊦ W3 ≠ idle; (s) ⊦ W4 ≠ idle; (s) ⊦ W5 ≠ idle; (s) ⊦ W6 ≠ idle; (s) ⊦ W7 ≠ idle; (s)

Proof step 165 from proof step-absstep-CRASH-globalCRASH (previous step) (back to tree)

User applied rule constructor cut

And closed the goal!

Rule argument

Additional information

Used simplifier rules: FLITPC freely generated by R1, R2, R3, R4, W1, W2, W3, W4, W5, W6, W7, crashed, idle, ready ;;