Proof step 1 from proof reachable-addnew-rev (conclusion) (back to tree)

System applied rule normalize

And obtained the following new goals

• Proof step 2:

  r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h ⊦ reachable(r, r1, h(r2 := ce)) ↔ (∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ r2 ≠ null ∧ (r1 = r2 ∨ reachable(ce.nxt, r1, h)))

Rule argument

Additional information

Proof step 2 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 3:

  r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h ⊦ reachable(r, r1, h(r2 := ce)) ↔ (∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h)))

Rule argument

Additional information

Proof step 3 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 4:

  reachable(r, r1, h(r2 := ce)), r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h))

• Proof step 85:

  r ∈ h, ¬ reachable(r, r1, h(r2 := ce)), ¬ reachable(r, r1, h), ¬ r2 ∈ h, ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h)) ⊦

Rule argument

Additional information

Proof step 4 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 5:

  reachable(r, r1, h(r2 := ce)), r ∈ h, r1 ∈ h(r2 := ce), ¬ reachable(r, r1, h), ¬ r2 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h))

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 5 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 6:

  ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st

• Proof step 7:

  reachable(r, r1, h(r2 := ce)), r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h, r1 = r2 ∨ r1 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h))

Rule argument

Additional information

Used terms: ce, r2, h, r1

Proof step 6 from proof reachable-addnew-rev (previous step) (back to tree)

A spec-lemma

Proof step 7 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 8:

  r1 = r2, reachable(r, r1, h(r2 := ce)), r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h, r1 = r2 ∨ r1 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h))

• Proof step 27:

  r1 ≠ r2, reachable(r, r1, h(r2 := ce)), r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h, r1 = r2 ∨ r1 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ (r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h))

Rule argument

Additional information

Used formulas: r1 = r2

Proof step 8 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 9:

  reachable(r, r2, h(r2 := ce)), r ∈ h, ¬ r2 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: endnotinH-notreachable: ⊦ ¬ r0 ∈ h → (reachable(r, r0, h) ↔ false); reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h; ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 9 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 10:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0 ∧ ¬ dups(r ' + x))

• Proof step 11:

  r ∈ h, ¬ r2 ∈ h, ∃ x. path(r ' + x, h(r2 := ce)) ∧ (r ' + x).last = r2 ∧ ¬ dups(r ' + x) ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used terms: h(r2 := ce), r2, r

Proof step 10 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-nodups-def

Proof step 11 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 12:

  path(r ' + x, h((r ' + x).last := ce)), r ∈ h, ¬ dups(x), ¬ (r ' + x).last ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = (r ' + x).last ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ dups(a ' + x) ↔ a ∈ x ∨ dups(x); (s)

Proof step 12 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 13:

  x ≠ [], path(r ' + x, h((r ' + x).last := ce)), r ∈ h, ¬ dups(x), ¬ (r ' + x).last ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = (r ' + x).last ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: path-one: ⊦ path(r ', h) ↔ r ∈ h ∧ r ≠ null; ⊦ a ∈ st(a := d); (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a '.last = a; (s) Used formulas: x = []

Proof step 13 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 14:

  x ≠ [], path(r ' + x, h(x.last := ce)), r ∈ h, ¬ dups(x), ¬ r ∈ x, ¬ x.last ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = x.last ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ x ≠ [] → (a ' + x).last = x.last; (s)

Proof step 14 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply elim lemma

And obtained the following new goals

• Proof step 15:

  x = x0 + r1 ', x ≠ [], path(r ' + x, h(r1 := ce)), r ∈ h, ¬ dups(x), ¬ r ∈ x, ¬ r1 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r1 ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: x, r1, x0

Proof step 15 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 16:

  path(r ' + x0 + r1 ', h(r1 := ce)), r ∈ h, ¬ dups(x0), ¬ r1 ∈ h, ¬ r1 ∈ x0, ¬ r ∈ x0 ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r1 ∧ (h(r0)).nxt ≠ null

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) ⊦ dups(x + a ') ↔ a ∈ x ∨ dups(x); (ws) ⊦ x + a ' ≠ []; (s)

Proof step 16 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 17:

  path(r ' + x0 + r1 ', h(r1 := ce)), r ∈ h, ¬ dups(x0), ¬ r1 ∈ h, ¬ r1 ∈ x0, ¬ r ∈ x0 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r1 ∧ (h((r ' + x0).last)).nxt ≠ null

Rule argument

Additional information

Used terms: (r ' + x0).last

Proof step 17 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 18:

  ⊦ path(r ' + x + r0 ', h) ↔ path(r ' + x, h) ∧ (h((r ' + x).last)).nxt = r0 ∧ r0 ∈ h ∧ r0 ≠ null

• Proof step 19:

  (h(r1 := ce)((r ' + x0).last)).nxt = r1, r1 ≠ null, path(r ' + x0, h(r1 := ce)), r ∈ h, r1 ∈ h(r1 := ce), ¬ dups(x0), ¬ r1 ∈ h, ¬ r1 ∈ x0, ¬ r ∈ x0 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r1 ∧ (h((r ' + x0).last)).nxt ≠ null

Rule argument

Additional information

Used terms: h(r1 := ce), r1, x0, r

Proof step 18 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma path-split-last

Proof step 19 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 20:

  (h(r1 := ce)((r ' + x0).last)).nxt = r1, r1 ≠ null, path(r ' + x0, h), r ∈ h, ¬ dups(x0), ¬ r1 ∈ h, ¬ r1 ∈ x0, ¬ r ∈ x0 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r1

Rule argument

Additional information

Used simplifier rules: path-new-irrelevant-strong: ⊦ ¬ r2 ∈ h ∧ ¬ r2 ∈ x ∧ r ∈ h → (path(r ' + x, h(r2 := ce)) ↔ path(r ' + x, h)); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 20 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 21:

  ⊦ a ≠ b → st(b := d)(a) = st(a)

• Proof step 22:

  (h((r ' + x0).last)).nxt = r1, (r ' + x0).last ≠ r1, r1 ≠ null, path(r ' + x0, h), r ∈ h, ¬ dups(x0), ¬ r1 ∈ h, ¬ r1 ∈ x0, ¬ r ∈ x0 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r1

Rule argument

Additional information

Used simplifier rules: path-last: ⊦ path(r ' + x, h) → ((r ' + x).last ∈ h ↔ true); ⊦ st(a := d)(a) = d; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used terms: (r ' + x0).last, ce, r1, h

Proof step 21 from proof reachable-addnew-rev (previous step) (back to tree)

A spec-lemma

Proof step 22 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 23:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), r ∈ h, ¬ dups(x0), ¬ reachable(r, (r ' + x0).last, h), ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ r ∈ x0 ⊦

Rule argument

Additional information

Proof step 23 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 24:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 25:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), r ∈ h, ¬ dups(x0), ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ r ∈ x0, ∀ x. ¬(path(r ' + x, h) ∧ (r ' + x).last = (r ' + x0).last) ⊦

Rule argument

Additional information

Used terms: h, (r ' + x0).last, r

Proof step 24 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 25 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 26:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), r ∈ h, ¬ dups(x0), ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ r ∈ x0, ∀ x. ¬ path(r ' + x, h) ∨ (r ' + x).last ≠ (r ' + x0).last ⊦

Rule argument

Additional information

Proof step 26 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: x0

Proof step 27 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 28:

  r1 ≠ r2, reachable(r, r1, h(r2 := ce)), r ∈ h, r1 ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, r1, h)

Rule argument

Additional information

Proof step 28 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 29:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0 ∧ ¬ dups(r ' + x))

• Proof step 30:

  r1 ≠ r2, r1 ∈ h, r ∈ h, ¬ reachable(r, r1, h), ¬ r2 ∈ h, ∃ x. path(r ' + x, h(r2 := ce)) ∧ (r ' + x).last = r1 ∧ ¬ dups(r ' + x) ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, r1, h)

Rule argument

Additional information

Used terms: h(r2 := ce), r1, r

Proof step 29 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-nodups-def

Proof step 30 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 31:

  (r ' + x).last ≠ r2, path(r ' + x, h(r2 := ce)), r ∈ h, (r ' + x).last ∈ h, ¬ dups(x), ¬ reachable(r, (r ' + x).last, h), ¬ r2 ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ dups(a ' + x) ↔ a ∈ x ∨ dups(x); (s)

Proof step 31 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 32:

  (r ' + x).last ≠ r2, path(r ' + x, h(r2 := ce)), (r ' + x).last ∈ h, r ∈ h, r2 ∈ x, ¬ dups(x), ¬ reachable(r, (r ' + x).last, h), ¬ r2 ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

• Proof step 80:

  (r ' + x).last ≠ r2, path(r ' + x, h(r2 := ce)), (r ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ reachable(r, (r ' + x).last, h), ¬ r2 ∈ x, ¬ r2 ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

Rule argument

Additional information

Used formulas: r2 ∈ x

Proof step 32 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 33:

  x.last ≠ r2, path(r ' + x, h(r2 := ce)), r2 ∈ x, r ∈ h, x.last ∈ h, ¬ dups(x), ¬ reachable(r, x.last, h), ¬ r2 ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, x.last, h)

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ x → (b ' + x).last = x.last; (s)

Proof step 33 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 34:

  ⊦ a ∈ x ↔ (∃ y, z. x = y + (a + z))

• Proof step 35:

  x.last ≠ r2, path(r ' + x, h(r2 := ce)), x.last ∈ h, r ∈ h, ¬ dups(x), ¬ reachable(r, x.last, h), ¬ r2 ∈ h, ¬ r ∈ x, ∃ y, z. x = y + (r2 + z) ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, x.last, h)

Rule argument

Additional information

Used terms: x, r2

Proof step 34 from proof reachable-addnew-rev (previous step) (back to tree)

A spec-lemma

Proof step 35 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 36:

  (r2 ' + x1).last ≠ r2, path(r ' + x0 + r2 ' + x1, h(r2 := ce)), r ∈ h, (r2 ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h)

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ (x + a ' + y).last = (a ' + y).last; (s) ⊦ a + x = a ' + x; (s) ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) ⊦ dups(x + a ' + y) ↔ a ∈ x ∨ a ∈ y ∨ dups(x + y); (ws)

Proof step 36 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 37:

  (r2 ' + x1).last ≠ r2, path(r ' + x0 + r2 ' + x1, h(r2 := ce)), (r2 ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r + x0).last, h) ∧ (h((r + x0).last)).nxt = r2 ∧ (h((r + x0).last)).nxt ≠ null ∧ reachable(ce.nxt, ((h((r + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Used terms: (r + x0).last

Proof step 37 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 38:

  (r2 ' + x1).last ≠ r2, path(r ' + x0 + r2 ' + x1, h(r2 := ce)), r ∈ h, (r2 ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r2 ∧ (h((r ' + x0).last)).nxt ≠ null ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

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

Proof step 38 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 39:

  (r2 ' + x1).last ≠ r2, path(r ' + x0 + r2 ' + x1, h(r2 := ce)), path(r ' + x0 + r2 ', h(r2 := ce)), (r2 ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r2 ∧ (h((r ' + x0).last)).nxt ≠ null ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Used simplifier rules: path-prefix: ⊦ path(r ' + x + y, h) → (path(r ' + x, h) ↔ true); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used formulas: path(r ' + x0 + r2 ', h(r2 := ce))

Proof step 39 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 40:

  ⊦ path(r ' + x + r0 ', h) ↔ path(r ' + x, h) ∧ (h((r ' + x).last)).nxt = r0 ∧ r0 ∈ h ∧ r0 ≠ null

• Proof step 41:

  (h(r2 := ce)((r ' + x0).last)).nxt = r2, (r2 ' + x1).last ≠ r2, r2 ≠ null, path(r ' + x0, h(r2 := ce)), path(r ' + x0 + r2 ' + x1, h(r2 := ce)), r ∈ h, (r2 ' + x1).last ∈ h, r2 ∈ h(r2 := ce), ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r2 ∧ (h((r ' + x0).last)).nxt ≠ null ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Used terms: h(r2 := ce), r2, x0, r

Proof step 40 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma path-split-last

Proof step 41 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 42:

  (h(r2 := ce)((r ' + x0).last)).nxt = r2, (r2 ' + x1).last ≠ r2, r2 ≠ null, path(r ' + x0 + r2 ' + x1, h(r2 := ce)), path(r ' + x0, h), (r2 ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r2 ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Used simplifier rules: path-new-irrelevant-strong: ⊦ ¬ r2 ∈ h ∧ ¬ r2 ∈ x ∧ r ∈ h → (path(r ' + x, h(r2 := ce)) ↔ path(r ' + x, h)); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 42 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 43:

  ⊦ a ≠ b → st(b := d)(a) = st(a)

• Proof step 44:

  (h((r ' + x0).last)).nxt = r2, (r ' + x0).last ≠ r2, (r2 ' + x1).last ≠ r2, r2 ≠ null, path(r ' + x0, h), path(r ' + x0 + r2 ' + x1, h(r2 := ce)), r ∈ h, (r2 ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r2 ' + x1).last, h), ¬ r2 ∈ x0, ¬ r2 ∈ x1, ¬ r2 ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ (h((r ' + x0).last)).nxt = r2 ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Used simplifier rules: path-last: ⊦ path(r ' + x, h) → ((r ' + x).last ∈ h ↔ true); ⊦ st(a := d)(a) = d; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used terms: (r ' + x0).last, ce, r2, h

Proof step 43 from proof reachable-addnew-rev (previous step) (back to tree)

A spec-lemma

Proof step 44 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 45:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), path(r ' + x0, h), ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦ reachable(r, (r ' + x0).last, h) ∧ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h)

Rule argument

Additional information

Proof step 45 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 46:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), r ∈ h, ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, (r ' + x0).last, h), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

• Proof step 50:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), r ∈ h, ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

Rule argument

Additional information

Proof step 46 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 47:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 48:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), path(r ' + x0, h), ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1, ∀ x. ¬(path(r ' + x, h) ∧ (r ' + x).last = (r ' + x0).last) ⊦

Rule argument

Additional information

Used terms: h, (r ' + x0).last, r

Proof step 47 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 48 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 49:

  (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0, h), path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), r ∈ h, ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1, ∀ x. ¬ path(r ' + x, h) ∨ (r ' + x).last ≠ (r ' + x0).last ⊦

Rule argument

Additional information

Proof step 49 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: x0

Proof step 50 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 51:

  ⊦ y ≠ [] → (x + y).last = y.last

• Proof step 52:

  x0 = [], (r ' + x0).last ≠ (h((r ' + x0).last)).nxt, ((h((r ' + x0).last)).nxt ' + x1).last ≠ (h((r ' + x0).last)).nxt, (h((r ' + x0).last)).nxt ≠ null, path(r ' + x0 + (h((r ' + x0).last)).nxt ' + x1, h((h((r ' + x0).last)).nxt := ce)), path(r ' + x0, h), ((h((r ' + x0).last)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(ce.nxt, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ reachable(r, ((h((r ' + x0).last)).nxt ' + x1).last, h), ¬ (h((r ' + x0).last)).nxt ∈ x0, ¬ (h((r ' + x0).last)).nxt ∈ x1, ¬ (h((r ' + x0).last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

• Proof step 64:

  x0.last ≠ (h(x0.last)).nxt, ((h(x0.last)).nxt ' + x1).last ≠ (h(x0.last)).nxt, (h(x0.last)).nxt ≠ null, x0 ≠ [], path(r ' + x0 + (h(x0.last)).nxt ' + x1, h((h(x0.last)).nxt := ce)), path(r ' + x0, h), ((h(x0.last)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(ce.nxt, ((h(x0.last)).nxt ' + x1).last, h), ¬ reachable(r, ((h(x0.last)).nxt ' + x1).last, h), ¬ (h(x0.last)).nxt ∈ x0, ¬ (h(x0.last)).nxt ∈ x1, ¬ (h(x0.last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

Rule argument

Additional information

Used terms: x0, r '

Proof step 51 from proof reachable-addnew-rev (previous step) (back to tree)

A spec-lemma

Proof step 52 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 53:

  ((h(r)).nxt ' + x1).last ≠ (h(r)).nxt, (h(r)).nxt ≠ null, r ≠ (h(r)).nxt, r ≠ null, path((h(r)).nxt ' + x1, h((h(r)).nxt := ce)), r ∈ h, ((h(r)).nxt ' + x1).last ∈ h, ¬ dups(x1), ¬ reachable(ce.nxt, ((h(r)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ (h(r)).nxt ∈ x1, ¬ (h(r)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: path-one: ⊦ path(r ', h) ↔ r ∈ h ∧ r ≠ null; path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); ⊦ ¬ a ∈ []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ x + [] = x; (s) ⊦ [] + x = x; (s) ⊦ a ≠ b → st(b := d)(a) = st(a); (s) ⊦ a ≠ b → (a ∈ st(b := d) ↔ a ∈ st); (s)

Proof step 53 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule constructor cut

And obtained the following new goals

• Proof step 54:

  x1 = r0 + x, ((h(r)).nxt ' + x1).last ≠ (h(r)).nxt, (h(r)).nxt ≠ null, r ≠ (h(r)).nxt, r ≠ null, path((h(r)).nxt ' + x1, h((h(r)).nxt := ce)), ((h(r)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x1), ¬ reachable(ce.nxt, ((h(r)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ (h(r)).nxt ∈ x1, ¬ (h(r)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: Reflist freely generated by [], +; ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a '.last = a; (s)

Proof step 54 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 55:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(ce.nxt, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ b ' + x ↔ ¬(a ≠ b ∧ ¬ a ∈ x); (ss) ⊦ a + x = a ' + x; (s) ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ dups(a ' + x) ↔ a ∈ x ∨ dups(x); (s) ⊦ st(a := d)(a) = d; (s) ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 55 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 56:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 57:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), r ∈ h, (ce.nxt ' + x).last ∈ h, ¬ dups(x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h, ∀ x0. ¬(path(ce.nxt ' + x0, h) ∧ (ce.nxt ' + x0).last = (ce.nxt ' + x).last) ⊦

Rule argument

Additional information

Used terms: h, (ce.nxt ' + x).last, ce.nxt

Proof step 56 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 57 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 58:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h, ∀ x0. ¬ path(ce.nxt ' + x0, h) ∨ (ce.nxt ' + x0).last ≠ (ce.nxt ' + x).last ⊦

Rule argument

Additional information

Proof step 58 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 59:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), r ∈ h, (ce.nxt ' + x).last ∈ h, ¬ dups(x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h, ¬ path(ce.nxt ' + x, h) ∨ (ce.nxt ' + x).last ≠ (ce.nxt ' + x).last ⊦

Rule argument

Additional information

Used terms: x

Proof step 59 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 60:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ path(ce.nxt ' + x, h), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h ⊦

Rule argument

Additional information

Proof step 60 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 61:

  ⊦ ¬ r2 ∈ h ∧ ¬ r2 ∈ x ∧ r ∈ h → (path(r ' + x, h(r2 := ce)) ↔ path(r ' + x, h))

• Proof step 62:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), r ∈ h, (ce.nxt ' + x).last ∈ h, ¬ dups(x), ¬ path(ce.nxt ' + x, h), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h ⊦ ¬ (h(r)).nxt ∈ h ∧ ¬ (h(r)).nxt ∈ x ∧ ce.nxt ∈ h

Rule argument

Additional information

Used terms: ce, h, x, ce.nxt, (h(r)).nxt

Proof step 61 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma path-new-irrelevant-strong

Proof step 62 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 63:

  (ce.nxt ' + x).last ≠ (h(r)).nxt, (h(r)).nxt ≠ ce.nxt, (h(r)).nxt ≠ null, r ≠ ce.nxt, r ≠ null, r ≠ (h(r)).nxt, path(ce.nxt ' + x, h((h(r)).nxt := ce)), (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ path(ce.nxt ' + x, h), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r)).nxt ∈ x, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ (h(r)).nxt ∈ h, ¬ ce.nxt ∈ h ⊦

Rule argument

Additional information

Proof step 63 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule constructor cut

And closed the goal!

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); Reflist freely generated by [], +; ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ a + x = a ' + x; (s) ⊦ a ≠ b → (a ∈ st(b := d) ↔ a ∈ st); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ x + [] = x; (s) ⊦ a '.last = a; (s)

Proof step 64 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 65:

  x0.last ≠ (h(x0.last)).nxt, ((h(x0.last)).nxt ' + x1).last ≠ (h(x0.last)).nxt, (h(x0.last)).nxt ≠ null, x0 ≠ [], path(r ' + x0, h), path(r ' + x0 + (h(x0.last)).nxt ' + x1, h((h(x0.last)).nxt := ce)), r ∈ h, ((h(x0.last)).nxt ' + x1).last ∈ h, ¬ dups(x0 + x1), ¬ reachable(ce.nxt, ((h(x0.last)).nxt ' + x1).last, h), ¬ reachable(r, ((h(x0.last)).nxt ' + x1).last, h), ¬ (h(x0.last)).nxt ∈ x0, ¬ (h(x0.last)).nxt ∈ x1, ¬ (h(x0.last)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

Rule argument

Additional information

Proof step 65 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply elim lemma

And obtained the following new goals

• Proof step 66:

  x0 = x2 + r0 ', ((h(r0)).nxt ' + x1).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ null, r0 ≠ (h(r0)).nxt, x0 ≠ [], path(r ' + x0 + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), path(r ' + x0, h), ((h(r0)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x0 + x1), ¬ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r0)).nxt ' + x1).last, h), ¬ (h(r0)).nxt ∈ x0, ¬ (h(r0)).nxt ∈ x1, ¬ (h(r0)).nxt ∈ h, ¬ r ∈ x0, ¬ r ∈ x1 ⊦

Rule argument

Additional information

Used simplifier rules: x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: x0, r0, x2

Proof step 66 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 67:

  ((h(r0)).nxt ' + x1).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ null, r ≠ r0, r0 ≠ (h(r0)).nxt, path(r ' + x2 + r0 ', h), path(r ' + (x2 + r0 ') + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), r ∈ h, ((h(r0)).nxt ' + x1).last ∈ h, ¬ dups(x2 + x1), ¬ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r0)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ r0 ∈ x2, ¬ r0 ∈ x1, ¬ (h(r0)).nxt ∈ x2, ¬ (h(r0)).nxt ∈ x1, ¬ (h(r0)).nxt ∈ h, ¬ r ∈ x2 ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ b ' ↔ a = b; (s) ⊦ a ∈ x + y ↔ a ∈ x ∨ a ∈ y; (s) ⊦ dups(x + a ' + y) ↔ a ∈ x ∨ a ∈ y ∨ dups(x + y); (ws) ⊦ x + a ' ≠ []; (s)

Proof step 67 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 68:

  ((h(r0)).nxt ' + x1).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ null, r ≠ r0, r0 ≠ (h(r0)).nxt, path(r ' + (x2 + r0 ') + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), path(r0 ' + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), ((h(r0)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x2 + x1), ¬ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r0)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ r0 ∈ x2, ¬ r0 ∈ x1, ¬ (h(r0)).nxt ∈ x2, ¬ (h(r0)).nxt ∈ x1, ¬ (h(r0)).nxt ∈ h, ¬ r ∈ x2 ⊦

Rule argument

Additional information

Used simplifier rules: path-postfix: ⊦ path(x + r ' + y, h) → (path(r ' + y, h) ↔ true); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used formulas: path(r0 ' + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce))

Proof step 68 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 69:

  ((h(r0)).nxt ' + x1).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ null, r ≠ r0, r0 ≠ (h(r0)).nxt, r0 ≠ null, path(r ' + x2 + r0 ', h), path(r ' + (x2 + r0 ') + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), path((h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), r ∈ h, ((h(r0)).nxt ' + x1).last ∈ h, r0 ∈ h, ¬ dups(x2 + x1), ¬ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r0)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ r0 ∈ x2, ¬ r0 ∈ x1, ¬ (h(r0)).nxt ∈ x2, ¬ (h(r0)).nxt ∈ x1, ¬ (h(r0)).nxt ∈ h, ¬ r ∈ x2 ⊦

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ b ∈ st ∧ ¬ a ∈ st → st(a := d)(b) = st(b); (s) ⊦ a ≠ b → (a ∈ st(b := d) ↔ a ∈ st); (s)

Proof step 69 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule constructor cut

And obtained the following new goals

• Proof step 70:

  x1 = r1 + x, ((h(r0)).nxt ' + x1).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ null, r ≠ r0, r0 ≠ (h(r0)).nxt, r0 ≠ null, path((h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), path(r ' + (x2 + r0 ') + (h(r0)).nxt ' + x1, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), r0 ∈ h, ((h(r0)).nxt ' + x1).last ∈ h, r ∈ h, ¬ dups(x2 + x1), ¬ reachable(ce.nxt, ((h(r0)).nxt ' + x1).last, h), ¬ reachable(r, ((h(r0)).nxt ' + x1).last, h), ¬ r ∈ x1, ¬ r0 ∈ x2, ¬ r0 ∈ x1, ¬ (h(r0)).nxt ∈ x2, ¬ (h(r0)).nxt ∈ x1, ¬ (h(r0)).nxt ∈ h, ¬ r ∈ x2 ⊦

Rule argument

Additional information

Used simplifier rules: Reflist freely generated by [], +; ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a '.last = a; (s)

Proof step 70 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 71:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), r0 ∈ h, (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(ce.nxt, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ a ∈ b ' + x ↔ ¬(a ≠ b ∧ ¬ a ∈ x); (ss) ⊦ a + x = a ' + x; (s) ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ dups(x + a ' + y) ↔ a ∈ x ∨ a ∈ y ∨ dups(x + y); (ws) ⊦ st(a := d)(a) = d; (s) ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 71 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 72:

  ⊦ ¬ r2 ∈ h ∧ ¬ r2 ∈ x ∧ r ∈ h → (path(r ' + x, h(r2 := ce)) ↔ path(r ' + x, h))

• Proof step 73:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(r ' + x2 + r0 ', h), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(ce.nxt ' + x, h((h(r0)).nxt := ce)), r ∈ h, (ce.nxt ' + x).last ∈ h, r0 ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(ce.nxt, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h ⊦ ¬ (h(r0)).nxt ∈ h ∧ ¬ (h(r0)).nxt ∈ x ∧ ce.nxt ∈ h

• Proof step 75:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(r ' + x2 + r0 ', h), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(ce.nxt ' + x, h), r ∈ h, (ce.nxt ' + x).last ∈ h, r0 ∈ h, ce.nxt ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(ce.nxt, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used terms: ce, h, x, ce.nxt, (h(r0)).nxt

Proof step 72 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma path-new-irrelevant-strong

Proof step 73 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 74:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), r0 ∈ h, (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h, ¬ ce.nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: startnotinH-notreachable: ⊦ ¬ r ∈ h → (reachable(r, r0, h) ↔ false);

Proof step 74 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule constructor cut

And closed the goal!

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); Reflist freely generated by [], +; ⊦ (b ' + a ' + x).last = (a ' + x).last; (s) ⊦ a + x = a ' + x; (s) ⊦ a ≠ b → (a ∈ st(b := d) ↔ a ∈ st); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] ⊦ x + [] = x; (s) ⊦ a '.last = a; (s)

Proof step 75 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 76:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(ce.nxt ' + x, h), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), ce.nxt ∈ h, r0 ∈ h, (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(ce.nxt, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Proof step 76 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 77:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 78:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(r ' + x2 + r0 ', h), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(ce.nxt ' + x, h), r ∈ h, (ce.nxt ' + x).last ∈ h, r0 ∈ h, ce.nxt ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h, ∀ x0. ¬(path(ce.nxt ' + x0, h) ∧ (ce.nxt ' + x0).last = (ce.nxt ' + x).last) ⊦

Rule argument

Additional information

Used terms: h, (ce.nxt ' + x).last, ce.nxt

Proof step 77 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 78 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 79:

  (ce.nxt ' + x).last ≠ (h(r0)).nxt, (h(r0)).nxt ≠ ce.nxt, (h(r0)).nxt ≠ null, r ≠ ce.nxt, r ≠ r0, r0 ≠ ce.nxt, r0 ≠ null, r0 ≠ (h(r0)).nxt, path(ce.nxt ' + x, h), path(r ' + x2 + r0 ' + (h(r0)).nxt ' + ce.nxt ' + x, h((h(r0)).nxt := ce)), path(r ' + x2 + r0 ', h), ce.nxt ∈ h, r0 ∈ h, (ce.nxt ' + x).last ∈ h, r ∈ h, ¬ dups(x2 + x), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ x, ¬ (h(r0)).nxt ∈ x2, ¬ r0 ∈ x, ¬ r0 ∈ x2, ¬ r ∈ x, ¬ ce.nxt ∈ x, ¬ ce.nxt ∈ x2, ¬ r ∈ x2, ¬ (h(r0)).nxt ∈ h, ∀ x0. ¬ path(ce.nxt ' + x0, h) ∨ (ce.nxt ' + x0).last ≠ (ce.nxt ' + x).last ⊦

Rule argument

Additional information

Proof step 79 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: x

Proof step 80 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 81:

  (r ' + x).last ≠ r2, path(r ' + x, h), r ∈ h, (r ' + x).last ∈ h, ¬ dups(x), ¬ reachable(r, (r ' + x).last, h), ¬ r2 ∈ x, ¬ r2 ∈ h, ¬ r ∈ x ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

Rule argument

Additional information

Used simplifier rules: path-new-irrelevant-strong: ⊦ ¬ r2 ∈ h ∧ ¬ r2 ∈ x ∧ r ∈ h → (path(r ' + x, h(r2 := ce)) ↔ path(r ' + x, h)); a: ⊦ (x + y) + z = x + y + z; from specification list[reflist]

Proof step 81 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 82:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 83:

  (r ' + x).last ≠ r2, path(r ' + x, h), (r ' + x).last ∈ h, r ∈ h, ¬ dups(x), ¬ r2 ∈ x, ¬ r2 ∈ h, ¬ r ∈ x, ∀ x0. ¬(path(r ' + x0, h) ∧ (r ' + x0).last = (r ' + x).last) ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

Rule argument

Additional information

Used terms: h, (r ' + x).last, r

Proof step 82 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 83 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 84:

  (r ' + x).last ≠ r2, path(r ' + x, h), r ∈ h, (r ' + x).last ∈ h, ¬ dups(x), ¬ r2 ∈ x, ¬ r2 ∈ h, ¬ r ∈ x, ∀ x0. ¬ path(r ' + x0, h) ∨ (r ' + x0).last ≠ (r ' + x).last ⊦ ∃ r0. reachable(r, r0, h) ∧ (h(r0)).nxt = r2 ∧ (h(r0)).nxt ≠ null ∧ reachable(ce.nxt, (r ' + x).last, h)

Rule argument

Additional information

Proof step 84 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: x

Proof step 85 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 86:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), r ∈ h, r0 ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 86 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 87:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used simplifier rules: reachable-addnew: ⊦ reachable(r, r1, h) ∧ ¬ r2 ∈ h → (reachable(r, r1, h(r2 := ce)) ↔ true); Used formulas: reachable(r, r0, h((h(r0)).nxt := ce))

Proof step 87 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 88:

  (h(r0)).nxt ≠ null, reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 88 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 89:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

• Proof step 107:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used formulas: reachable(ce.nxt, r1, h((h(r0)).nxt := ce))

Proof step 89 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 90:

  (h(r0)).nxt ≠ null, reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), r1 ∈ h((h(r0)).nxt := ce), ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 90 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 91:

  ⊦ reachable(r, r0, h) ∧ reachable(r0, r1, h) → reachable(r, r1, h)

• Proof step 92:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), r1 ∈ h((h(r0)).nxt := ce), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ (h(r0)).nxt ∈ h, reachable(r, r0, h((h(r0)).nxt := ce)) ∧ reachable(r0, r1, h((h(r0)).nxt := ce)) → reachable(r, r1, h((h(r0)).nxt := ce)), r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used terms: r, r0, h((h(r0)).nxt := ce), r1

Proof step 91 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-trans

Proof step 92 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 93:

  (h(r0)).nxt ≠ null, reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), r1 ∈ h((h(r0)).nxt := ce), ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ reachable(r0, r1, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h, r1 = (h(r0)).nxt ∨ reachable(ce.nxt, r1, h) ⊦

Rule argument

Additional information

Used simplifier rules: reachable-addnew: ⊦ reachable(r, r1, h) ∧ ¬ r2 ∈ h → (reachable(r, r1, h(r2 := ce)) ↔ true);

Proof step 93 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 94:

  r1 = (h(r0)).nxt, (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), r1 ∈ h((h(r0)).nxt := ce), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ reachable(r0, r1, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

• Proof step 99:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h), r1 ∈ h((h(r0)).nxt := ce), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ reachable(r0, r1, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Proof step 94 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 95:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, (h(r0)).nxt, h((h(r0)).nxt := ce)), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r0, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ reachable(r, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: reach-reachnext: ⊦ reachable(r, r1, h) → (reachable(r, (h(r1)).nxt, h) ↔ ¬((h(r1)).nxt = null ∨ ¬ (h(r1)).nxt ∈ h)); reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h; ⊦ a ∈ st(b := d) ↔ a = b ∨ a ∈ st; (ws)

Proof step 95 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 96:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 97:

  (h(r0)).nxt ≠ null, reachable(ce.nxt, (h(r0)).nxt, h((h(r0)).nxt := ce)), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), ¬ reachable(r, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h, ∀ x. ¬(path(r0 ' + x, h((h(r0)).nxt := ce)) ∧ (r0 ' + x).last = (h(r0)).nxt) ⊦

Rule argument

Additional information

Used terms: h((h(r0)).nxt := ce), (h(r0)).nxt, r0

Proof step 96 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 97 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 98:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(ce.nxt, (h(r0)).nxt, h((h(r0)).nxt := ce)), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h, ∀ x. ¬ path(r0 ' + x, h((h(r0)).nxt := ce)) ∨ (r0 ' + x).last ≠ (h(r0)).nxt ⊦

Rule argument

Additional information

Used simplifier rules: reachable-addnew: ⊦ reachable(r, r1, h) ∧ ¬ r2 ∈ h → (reachable(r, r1, h(r2 := ce)) ↔ true);

Proof step 98 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: path-two: ⊦ path(r ' + r0 ', h) ↔ r ∈ h ∧ r0 ∈ h ∧ r ≠ null ∧ r0 ≠ null ∧ (h(r)).nxt = r0; reachable-notnullinH: ⊦ reachable(r, r1, h) ∧ r1 ≠ null → (r1 ∈ h ↔ true); null-not-reachable: ⊦ ¬ reachable(r, null, h); ⊦ b ∈ st ∧ ¬ a ∈ st → st(a := d)(b) = st(b); (s) ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used terms: (h(r0)).nxt '

Proof step 99 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 100:

  (h(r0)).nxt ≠ null, reachable(ce.nxt, r1, h), reachable(ce.nxt, r1, h((h(r0)).nxt := ce)), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), r1 ∈ h((h(r0)).nxt := ce), r1 ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ reachable(r0, r1, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 100 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 101:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 102:

  (h(r0)).nxt ≠ null, reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, r1, h), r1 ∈ h, r1 ∈ h((h(r0)).nxt := ce), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, r1, h((h(r0)).nxt := ce)), ¬ reachable(r, r1, h), ¬ reachable(r0, r1, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h, ∃ x. path(ce.nxt ' + x, h((h(r0)).nxt := ce)) ∧ (ce.nxt ' + x).last = r1 ⊦

Rule argument

Additional information

Used terms: h((h(r0)).nxt := ce), r1, ce.nxt

Proof step 101 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 102 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 103:

  (h(r0)).nxt ≠ null, path(ce.nxt ' + x, h((h(r0)).nxt := ce)), reachable(ce.nxt, (ce.nxt ' + x).last, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), (ce.nxt ' + x).last ∈ h((h(r0)).nxt := ce), (ce.nxt ' + x).last ∈ h, ¬ reachable(r, (ce.nxt ' + x).last, h((h(r0)).nxt := ce)), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ reachable(r0, (ce.nxt ' + x).last, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: reach-alloc: ⊦ reachable(r, r1, h) → r1 ∈ h;

Proof step 103 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 104:

  ⊦ reachable(r, r0, h) ↔ (∃ x. path(r ' + x, h) ∧ (r ' + x).last = r0)

• Proof step 105:

  (h(r0)).nxt ≠ null, path(ce.nxt ' + x, h((h(r0)).nxt := ce)), reachable(r, r0, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(ce.nxt, (ce.nxt ' + x).last, h), (ce.nxt ' + x).last ∈ h, (ce.nxt ' + x).last ∈ h((h(r0)).nxt := ce), r0 ∈ h((h(r0)).nxt := ce), r0 ∈ h, r ∈ h, ¬ reachable(r, (ce.nxt ' + x).last, h((h(r0)).nxt := ce)), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ h, ∀ x0. ¬(path(r0 ' + x0, h((h(r0)).nxt := ce)) ∧ (r0 ' + x0).last = (ce.nxt ' + x).last) ⊦

Rule argument

Additional information

Used terms: h((h(r0)).nxt := ce), (ce.nxt ' + x).last, r0

Proof step 104 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reachable-def

Proof step 105 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 106:

  (h(r0)).nxt ≠ null, path(ce.nxt ' + x, h((h(r0)).nxt := ce)), reachable(ce.nxt, (ce.nxt ' + x).last, h), reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), (ce.nxt ' + x).last ∈ h((h(r0)).nxt := ce), (ce.nxt ' + x).last ∈ h, ¬ reachable(r, (ce.nxt ' + x).last, h((h(r0)).nxt := ce)), ¬ reachable(r, (ce.nxt ' + x).last, h), ¬ (h(r0)).nxt ∈ h, ∀ x0. ¬ path(r0 ' + x0, h((h(r0)).nxt := ce)) ∨ (r0 ' + x0).last ≠ (ce.nxt ' + x).last ⊦

Rule argument

Additional information

Proof step 106 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: path-cons: ⊦ path(r ' + r0 ' + x, h) ↔ r ∈ h ∧ r ≠ null ∧ (h(r)).nxt = r0 ∧ path(r0 ' + x, h); null-not-reachable: ⊦ ¬ reachable(r, null, h); ⊦ b ∈ st ∧ ¬ a ∈ st → st(a := d)(b) = st(b); (s) ⊦ a ∈ st(a := d); (s) ⊦ st(a := d)(a) = d; (s) ⊦ a + x = a ' + x; (s) ⊦ (a ' + x + b ' + y).last = (b ' + y).last; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[reflist] Used terms: (h(r0)).nxt + ce.nxt + x

Proof step 107 from proof reachable-addnew-rev (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 108:

  (h(r0)).nxt ≠ null, reachable(r, r0, h((h(r0)).nxt := ce)), reachable(r, r0, h), r ∈ h, r0 ∈ h, r0 ∈ h((h(r0)).nxt := ce), ¬ reachable(ce.nxt, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ reachable(r, (h(r0)).nxt, h((h(r0)).nxt := ce)), ¬ (h(r0)).nxt ∈ h ⊦

Rule argument

Additional information

Used simplifier rules: reachable-addnew: ⊦ reachable(r, r1, h) ∧ ¬ r2 ∈ h → (reachable(r, r1, h(r2 := ce)) ↔ true); endnotinH-notreachable: ⊦ ¬ r0 ∈ h → (reachable(r, r0, h) ↔ false); reach-reachnext: ⊦ reachable(r, r1, h) → (reachable(r, (h(r1)).nxt, h) ↔ ¬((h(r1)).nxt = null ∨ ¬ (h(r1)).nxt ∈ h));

Proof step 108 from proof reachable-addnew-rev (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 109:

  ⊦ reachable(r, r1, h) → (reachable(r, (h(r1)).nxt, h) ↔ ¬((h(r1)).nxt = null ∨ ¬ (h(r1)).nxt ∈ h))

Rule argument

Additional information

Used simplifier rules: reachable-addnew: ⊦ reachable(r, r1, h) ∧ ¬ r2 ∈ h → (reachable(r, r1, h(r2 := ce)) ↔ true); ⊦ a ∈ st(a := d); (s) ⊦ b ∈ st ∧ ¬ a ∈ st → st(a := d)(b) = st(b); (s) Used terms: r, r0, h((h(r0)).nxt := ce)

Proof step 109 from proof reachable-addnew-rev (previous step) (back to tree)

Lemma reach-reachnext