Proof step 1 from proof infinite-append-prefixnextli (conclusion) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 2:

  ∀ x. x ⊑ nextli(x), ∀ x. ∃ y. nextli(x) = x + y ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

• Proof step 194:

  ∀ x. x ⊑ nextli(x) ⊦ ∀ x. ∃ y. nextli(x) = x + y, ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Used formulas: ∀ x. ∃ y. nextli(x) = x + y

Proof step 2 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule weakening

And obtained the following new goals

• Proof step 3:

  ∀ x. ∃ y. nextli(x) = x + y ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Proof step 3 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule choice left

And obtained the following new goals

• Proof step 4:

  ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Proof step 4 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 5:

  ⊦ ∃ lf. lf(0) = [] ∧ (∀ n. lf(n + 1) = nextli(lf(n)))

• Proof step 6:

  ∀ x0. nextli(x0) = x0 + nextli0(x0), ∃ lf. lf(0) = [] ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Used terms: nextli

Proof step 5 from proof infinite-append-prefixnextli (previous step) (back to tree)

Lemma nextli-lemma

Proof step 6 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 7:

  lf(0) = [], ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Proof step 7 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 8:

  ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # lf(n) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# lf(n)) = lf(n)) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → lf(m) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1))

• Proof step 9:

  lf(0) = [], ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Used terms: λ n. nextli0(lf(n))

Proof step 8 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 9 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 10:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Proof step 10 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 11:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦ ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Used terms: σ, ii

Proof step 11 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 12:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ¬ # σ < ⌜ii(n0 + 1)⌝ ∧ σ.take(ii(n0 + 1)) = nextli(σ.take(ii(n0))) ∧ (# σ = ⌜ii(n0)⌝ ⊃ ii(n0) = ii(n0 + 1);ii(n0) < ii(n0 + 1)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)));∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1))

Rule argument

Additional information

Proof step 12 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 13:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ¬ # σ < ⌜ii(n0 + 1)⌝ ∧ σ.take(ii(n0 + 1)) = nextli(σ.take(ii(n0))) ∧ (# σ = ⌜ii(n0)⌝ ⊃ ii(n0) = ii(n0 + 1);ii(n0) < ii(n0 + 1)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)));∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1))

• Proof step 153:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦ ∀ n0. lf(n0) = σ.take(ii(n0)), ¬ # σ < ⌜ii(n0 + 1)⌝ ∧ σ.take(ii(n0 + 1)) = nextli(σ.take(ii(n0))) ∧ (# σ = ⌜ii(n0)⌝ ⊃ ii(n0) = ii(n0 + 1);ii(n0) < ii(n0 + 1)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)));∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1))

Rule argument

Additional information

Used formulas: ∀ n0. lf(n0) = σ.take(ii(n0))

Proof step 13 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 14:

  ii(0) = 0, lf(0) = [], # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

• Proof step 16:

  ii(0) = 0, lf(0) = [], σ.take(ii(n0 + 1)) ≠ nextli(σ.take(ii(n0))), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

• Proof step 20:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ (# σ = ⌜ii(n0)⌝ ⊃ ii(n0) = ii(n0 + 1);ii(n0) < ii(n0 + 1))

• Proof step 58:

  ii(0) = 0, lf(0) = [], (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)));∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1))

Rule argument

Additional information

Proof step 14 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 15:

  ii(0) = 0, lf(0) = [], # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Proof step 15 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n0

Proof step 16 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 17:

  ii(0) = 0, lf(0) = [], lf(n0 + 1) = σ.take(ii(n0 + 1)), σ.take(ii(n0 + 1)) ≠ nextli(σ.take(ii(n0))), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used terms: n0 + 1

Proof step 17 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 18:

  ii(0) = 0, lf(n0 + 1) = σ.take(ii(n0 + 1)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), σ.take(ii(n0 + 1)) ≠ nextli(σ.take(ii(n0))), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used terms: n0

Proof step 18 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 19:

  ii(0) = 0, lf(n0 + 1) = nextli(lf(n0)), lf(0) = [], nextli(lf(n0)) = σ.take(ii(n0 + 1)), nextli(lf(n0)) ≠ nextli(σ.take(ii(n0))), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Proof step 19 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n0

Proof step 20 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 21:

  # σ = ⌜ii(n0)⌝ , ii(0) = 0, lf(0) = [], ii(n0) ≠ ii(n0 + 1), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

• Proof step 23:

  ii(0) = 0, lf(0) = [], # σ ≠ ⌜ii(n0)⌝ , ¬ ii(n0) < ii(n0 + 1), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Proof step 21 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 22:

  # σ = ⌜ii(n0)⌝ , ii(0) = 0, lf(0) = [], ii(n0) ≠ ii(n0 + 1), (finp(σ) ⊃ ii(n0) = ii(n) ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ σ.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s)

Proof step 22 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m ≠ n → (m < n ↔ ¬ n < m); (ss) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ m < n → n ≠ 0; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n0

Proof step 23 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 24:

  ii(0) = 0, lf(0) = [], # σ ≠ ⌜ii(n0)⌝ , ii(n0 + 1) ≤ ii(n0), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 24 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 25:

  ii(0) = 0, ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), # σ ≠ ⌜ii(n0)⌝ , ii(n0 + 1) ≤ ii(n0), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used terms: n0

Proof step 25 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 26:

  ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), # σ ≠ ⌜ii(n0)⌝ , ii(n0 + 1) ≤ ii(n0), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Proof step 26 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 27:

  # nextli0(lf(n0)) = 0, ii(0) = 0, ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), # σ ≠ ⌜ii(n0)⌝ , ii(n0 + 1) ≤ ii(n0), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

• Proof step 56:

  ii(0) = 0, ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), # nextli0(lf(n0)) ≠ 0, # σ ≠ ⌜ii(n0)⌝ , ii(n0 + 1) ≤ ii(n0), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used formulas: # nextli0(lf(n0)) = 0

Proof step 27 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 28:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ # [] = 0; (s) ⊦ m ≤ m; (s) ⊦ σ.take(0) = []; (s) ⊦ # x = 0 ↔ x = []; (s)

Proof step 28 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 29:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0) ⊦

• Proof step 40:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0)

Rule argument

Additional information

Used formulas: ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0)

Proof step 29 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 30:

  # σ = ⌜ii(n)⌝ , ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , finp(σ), ¬ # σ < ⌜ii(n0)⌝ , ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n) ⊦

• Proof step 34:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , ¬ # σ < ⌜ii(n0)⌝ , ¬ finp(σ), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) ⊦

Rule argument

Additional information

Proof step 30 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 31:

  # x = ii(n), ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], ii(n) ≠ ii(n0), ii(n0) < ii(n), ∀ n1. lf(n1) = x.take(ii(n1)), ∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ ⌜x⌝ .take(n) = x.take(n); (s) ⊦ ⌜x⌝ .drop(n) = ⌜x.drop(n)⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ m ≠ n → (m < n ↔ ¬ n < m); (ss) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ finp(σ) ↔ (∃ x. ⌜x⌝ = σ); (as)

Proof step 31 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 32:

  # x = ii(n), ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], ii(n) ≠ ii(n0), ii(n0) < ii(n), n ≤ n0 → nextli0(lf(n0)) = [] ∧ ii(n0) = ii(n), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1)), ∀ n1. lf(n1) = x.take(ii(n1)) ⊦

Rule argument

Additional information

Used terms: n0

Proof step 32 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 33:

  # x = ii(n), ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], ii(n) ≠ ii(n0), n0 < n, ii(n0) < ii(n), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1)), ∀ n1. lf(n1) = x.take(ii(n1)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 33 from proof infinite-append-prefixnextli (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 34 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 35:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n. lf(n) = nf.take(ii(n)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ .take(n) = nf.take(n); (s) ⊦ ⌜nf⌝ .drop(n) = ⌜nf.drop(n)⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ⌜n⌝ ≠ ∞; (s) ⊦ finp(σ) ↔ ¬(∃ nf. ⌜nf⌝ = σ); (ss)

Proof step 35 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 36:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], ∀ n. lf(n) = nf.take(ii(n)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∃ m. ii(m) ≤ ii(n0) + 1 ∧ ii(n0) + 1 < ii(m + 1) ⊦

Rule argument

Additional information

Used terms: ii(n0) + 1

Proof step 36 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 37:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], ii(m) < ii(m + 1), ii(n0) + 1 < ii(m + 1), ii(m) ≤ ii(n0) + 1, ∀ n. lf(n) = nf.take(ii(n)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 37 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 38:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], ii(n0) + 1 < ii(m + 1), ii(m) < ii(m + 1), ii(m) ≤ ii(n0) + 1, m + 1 ≤ n0 → ii(m + 1) ≤ ii(n0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n. lf(n) = nf.take(ii(n)) ⊦

Rule argument

Additional information

Used terms: m + 1, n0

Proof step 38 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 39:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], ii(n0) < ii(m + 1), ii(m) < ii(m + 1), ii(n0) + 1 < ii(m + 1), n0 ≤ m, ii(m) ≤ ii(n0) + 1, ∀ n. lf(n) = nf.take(ii(n)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ m. n0 < m → ii(m) = ii(n0) ∧ lf(m) = lf(n0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → m ≤ n; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ ¬ m + n < m; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 39 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ n → (n < m ↔ false); (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m.+1 < n0; (forward) from specification nat-basic trans-nat: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic le-one: ⊦ m ≤ n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m < n → n ≠ 0; (s) ⊦ m.+1 = m + 1; (s) ⊦ m + m0 < n → ¬ n + n0 < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: m + 1

Proof step 40 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 41:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 < m, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ii(m) = ii(n0) ∧ lf(m) = lf(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 41 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule structural induction

And obtained the following new goals

• Proof step 42:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 < m0.+1, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ ii, n0, lf, nextli0, σ, n, nextli. ii(n0 + 1) = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ # σ ≠ ⌜ii(n0)⌝ ∧ n0 < m0 ∧ ¬ # σ < ⌜ii(n0)⌝ ∧ (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ∧ (∀ n0. lf(n0) = σ.take(ii(n0))) ∧ (∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0) ⊦ ii(m0.+1) = ii(n0) ∧ lf(m0.+1) = lf(n0)

Rule argument

Additional information

Used simplifier rules: Nat freely generated by 0, +1; ⊦ ¬ n < 0; (s)

Proof step 42 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 43:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 ≤ m0, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ ii, n0, lf, nextli0, σ, n, nextli. ii(n0 + 1) = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ # σ ≠ ⌜ii(n0)⌝ ∧ n0 < m0 ∧ ¬ # σ < ⌜ii(n0)⌝ ∧ (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ∧ (∀ n0. lf(n0) = σ.take(ii(n0))) ∧ (∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m.+1 = m + 1; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s)

Proof step 43 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 44:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 ≤ m0, ¬ # σ < ⌜ii(n0)⌝ , ii(n0 + 1) = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ # σ ≠ ⌜ii(n0)⌝ ∧ n0 < m0 ∧ ¬ # σ < ⌜ii(n0)⌝ ∧ (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ∧ (∀ n0. lf(n0) = σ.take(ii(n0))) ∧ (∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Used terms: ii, n0, lf, nextli0, σ, n, nextli

Proof step 44 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 45:

  ii(n0 + 1) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 ≤ m0, ¬ # σ < ⌜ii(n0)⌝ , n0 < m0 → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Proof step 45 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 46:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 < m0, n0 ≤ m0, ¬ # σ < ⌜ii(n0)⌝ , n0 < m0 → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

• Proof step 52:

  ii(0) = 0, ii(n0 + 1) = ii(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 ≤ m0, ¬ n0 < m0, ¬ # σ < ⌜ii(n0)⌝ , n0 < m0 → ii(m0) = ii(n0) ∧ lf(m0) = lf(n0), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Used formulas: n0 < m0

Proof step 46 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 47:

  ii(m0) = ii(n0), ii(0) = 0, ii(n0 + 1) = ii(n0), lf(m0) = lf(n0), lf(0) = [], nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , n0 < m0, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m < n → m ≤ n; (s)

Proof step 47 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 48:

  ii(n0 + 1) = ii(n0), ii(0) = 0, ii(m0) = ii(n0), ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), lf(0) = [], lf(m0) = lf(n0), nextli0(lf(n0)) = [], σ.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), # σ ≠ ⌜ii(n0)⌝ , n0 < m0, ¬ # σ < ⌜ii(m0 + 1)⌝ , ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ii(m0 + 1) = ii(n0) ∧ lf(m0 + 1) = lf(n0)

Rule argument

Additional information

Used terms: m0

Proof step 48 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 49:

  ii(n0 + 1) = ii(n0), ii(0) = 0, ii(m0) = ii(n0), ii(m0 + 1) = ii(n0), lf(0) = [], lf(m0) = lf(n0), nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , lf(m0 + 1) ≠ lf(n0), n0 < m0, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ σ.take(0) = []; (s) ⊦ # [] = 0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s)

Proof step 49 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 50:

  ii(m0 + 1) = ii(n0), ii(m0) = ii(n0), ii(0) = 0, ii(n0 + 1) = ii(n0), lf(m0) = lf(n0), lf(0) = [], lf(m0 + 1) = nextli(lf(m0)), nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , lf(m0 + 1) ≠ lf(n0), n0 < m0, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used terms: m0

Proof step 50 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 51:

  ii(n0 + 1) = ii(n0), ii(0) = 0, ii(m0) = ii(n0), ii(m0 + 1) = ii(n0), lf(m0 + 1) = nextli(lf(n0)), lf(0) = [], lf(m0) = lf(n0), nextli0(lf(n0)) = [], # σ ≠ ⌜ii(n0)⌝ , nextli(lf(n0)) ≠ lf(n0), n0 < m0, ¬ # σ < ⌜ii(n0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Proof step 51 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list Used terms: lf(n0)

Proof step 52 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 53:

  ii(0) = 0, ii(m0 + 1) = ii(m0), lf(0) = [], nextli0(lf(m0)) = [], # σ ≠ ⌜ii(m0)⌝ , lf(m0 + 1) ≠ lf(m0), ¬ # σ < ⌜ii(m0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ ¬ n < n; (s) ⊦ m ≤ m; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 53 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 54:

  ii(m0 + 1) = ii(m0), ii(0) = 0, lf(0) = [], lf(m0 + 1) = σ.take(ii(m0 + 1)), nextli0(lf(m0)) = [], # σ ≠ ⌜ii(m0)⌝ , lf(m0 + 1) ≠ lf(m0), ¬ # σ < ⌜ii(m0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used terms: m0 + 1

Proof step 54 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 55:

  ii(0) = 0, ii(m0 + 1) = ii(m0), lf(m0 + 1) = σ.take(ii(m0)), lf(0) = [], nextli0(lf(m0)) = [], # σ ≠ ⌜ii(m0)⌝ , σ.take(ii(m0)) ≠ lf(m0), ¬ # σ < ⌜ii(m0)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦

Rule argument

Additional information

Proof step 55 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: m0

Proof step 56 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 57:

  ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), # σ ≠ ⌜ii(n0)⌝ , nextli0(lf(n0)) ≠ [], ii(n0 + 1) ≤ ii(n0), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n0. lf(n0) = σ.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s)

Proof step 57 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule subst equation

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m + m0 ≤ m ↔ m0 = 0; (s) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 58 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic if-then-else split applied rule case distinction

And obtained the following new goals

• Proof step 59:

  ii(0) = 0, lf(0) = [], finp(σ), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)))

• Proof step 149:

  ii(0) = 0, lf(0) = [], ¬ finp(σ), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = σ.take(ii(n0)) ⊦ ∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1)

Rule argument

Additional information

Proof step 59 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 60:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = ⌜x0⌝ ↔ x = x0; (s) ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜x⌝ .take(n) = x.take(n); (s) ⊦ ⌜x⌝ .drop(n) = ⌜x.drop(n)⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ finp(⌜x⌝ ); (s) ⊦ finp(σ) ↔ (∃ x. ⌜x⌝ = σ); (as)

Proof step 60 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 61:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

• Proof step 133:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

Rule argument

Additional information

Used formulas: ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))

Proof step 61 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 62:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

Rule argument

Additional information

Proof step 62 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 63:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

• Proof step 104:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))), ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used formulas: ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Proof step 63 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 64:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

Rule argument

Additional information

Proof step 64 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 65:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1)))

Rule argument

Additional information

Used terms: n0

Proof step 65 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 66:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Proof step 66 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 67:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli(x) = x + nextli0(x), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: x

Proof step 67 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 68:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli(x) = x + nextli0(x), n ≤ n0 → nextli0(lf(n0)) = [] ∧ ii(n0) = ii(n), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n0

Proof step 68 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 69:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli(x) = x + nextli0(x), n ≤ n0, n ≤ n0 → nextli0(lf(n0)) = [] ∧ ii(n0) = ii(n), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

• Proof step 85:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli(x) = x + nextli0(x), ¬ n ≤ n0, n ≤ n0 → nextli0(lf(n0)) = [] ∧ ii(n0) = ii(n), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used formulas: n ≤ n0

Proof step 69 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 70:

  # x = ii(n), ii(0) = 0, ii(n0) = ii(n), lf(0) = [], nextli(x) = x + nextli0(x), nextli0(lf(n0)) = [], n ≤ n0, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Proof step 70 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 71:

  # x = ii(n), ii(n0) = ii(n), ii(0) = 0, ii(n + 1) = ii(n) + # nextli0(lf(n)), lf(0) = [], nextli(x) = x + nextli0(x), nextli0(lf(n0)) = [], x.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), n ≤ n0, ¬ ii(n) < ii(n + 1), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n

Proof step 71 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 72:

  # x = ii(n), ii(n + 1) = ii(n) + # nextli0(lf(n)), ii(0) = 0, ii(n0) = ii(n), lf(0) = [], nextli(x) = x + nextli0(x), nextli0(lf(n0)) = [], x.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), n ≤ n0, ii(n + 1) ≤ ii(n), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 72 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 73:

  # x = ii(n), ii(n0) = ii(n), ii(0) = 0, ii(n + 1) = ii(n) + # nextli0(lf(n)), lf(0) = [], nextli(x) = x + nextli0(x), nextli0(lf(n0)) = [], x.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ii(n + 1) ≤ ii(n), n ≤ n0, n ≤ n + 1 → ii(n) ≤ ii(n + 1), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n, n + 1

Proof step 73 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 74:

  # x = ii(n), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(x) = x + nextli0(x), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], n ≤ n0, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ x.take(0) = []; (s) ⊦ # [] = 0; (s) ⊦ m ≤ m; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m = m + n ↔ n = 0; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) ⊦ m ≤ m + n; (s)

Proof step 74 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 75:

  # x = ii(n), ii(n + 1) = ii(n), ii(n0) = ii(n), ii(0) = 0, lf(0) = [], lf(n) = x.take(ii(n)), nextli(x) = x + nextli0(x), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], n ≤ n0, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n

Proof step 75 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 76:

  # lf(n) = ii(n), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], n ≤ n0, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ (n0 ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ x + [] = x; (s) ⊦ # x = n → x.take(n) = x; (s)

Proof step 76 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 77:

  # lf(n) = ii(n), ii(n + 1) = ii(n), ii(n0) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], ii(m) ≠ ii(n), n ≤ n0, n0 ≤ m, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦

• Proof step 79:

  # lf(n) = ii(n), ii(n + 1) = ii(n), ii(n0) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], n ≤ n0, ¬ ii(m) < ii(m + 1), ¬ n0 ≤ m, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦

Rule argument

Additional information

Proof step 77 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 78:

  # lf(n) = ii(n), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], ii(m) ≠ ii(n), n0 ≤ m, n ≤ n0, n ≤ m, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat

Proof step 78 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: m

Proof step 79 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 80:

  # lf(n) = ii(n), ii(n + 1) = ii(n), ii(n0) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], m < n0, ii(m + 1) ≤ ii(m), n ≤ n0, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 80 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 81:

  # lf(n) = ii(n), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], m < n0, n ≤ n0, ii(m + 1) ≤ ii(m), m ≤ m + 1 → ii(m) ≤ ii(m + 1), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used terms: m, m + 1

Proof step 81 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 82:

  # lf(n) = ii(n), ii(m + 1) = ii(m), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], m < n0, n ≤ n0, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ m; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ m + n; (s)

Proof step 82 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 83:

  # lf(n) = ii(n), ii(n + 1) = ii(n), ii(n0) = ii(n), ii(0) = 0, ii(m + 1) = ii(m), ii(m + 1) = ii(m) + # nextli0(lf(m)), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], lf(n).drop(ii(m)).take(# nextli0(lf(m))) = nextli0(lf(m)), m < n0, n ≤ n0, ¬ ii(n) < ii(m + 1), ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦

Rule argument

Additional information

Used terms: m

Proof step 83 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 84:

  # lf(n) = ii(n), ii(m + 1) = ii(m), ii(0) = 0, ii(n0) = ii(n), ii(n + 1) = ii(n), lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], nextli0(lf(m)) = [], m < n0, n ≤ n0, ii(m) ≤ ii(n), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ x.take(0) = []; (s) ⊦ # [] = 0; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m = m + n ↔ n = 0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 84 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: m

Proof step 85 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 86:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli(x) = x + nextli0(x), n0 < n, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 86 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 87:

  # x = ii(n), ii(0) = 0, lf(0) = [], lf(n) = x.take(ii(n)), nextli(x) = x + nextli0(x), n0 < n, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ nextli(x) = x ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n

Proof step 87 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 88:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n) + nextli0(lf(n)), n0 < n, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ nextli(lf(n)) = lf(n) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ # x = n → x.take(n) = x; (s)

Proof step 88 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 89:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n) + nextli0(lf(n)), n0 < n, n ≤ n → nextli0(lf(n)) = [] ∧ ii(n) = ii(n), ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ nextli(lf(n)) = lf(n) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n

Proof step 89 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 90:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], n0 < n, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ x + [] = x; (s) ⊦ m ≤ m; (s)

Proof step 90 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 91:

  # lf(n) = ii(n), nextli0(lf(n0)) = [] ↔ n0 ≤ n0, ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], n0 < n, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n0

Proof step 91 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 92:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], n0 < n, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ m; (s)

Proof step 92 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 93:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], n0 < n, nextli0(lf(n0)) = [] → (∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n0

Proof step 93 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 94:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n)) = [], nextli0(lf(n0)) = [], n0 < n, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0) ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Proof step 94 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 95:

  # lf(n) = ii(n), ii(0) = 0, lf(0) = [], nextli(lf(n)) = lf(n), nextli0(lf(n0)) = [], nextli0(lf(n)) = [], n0 < n, n0 < n → lf(n) = lf(n0) ∧ nextli0(lf(n)) = [] ∧ ii(n) = ii(n0), ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ ii(n) = ii(n0) ∧ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Used terms: n

Proof step 95 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 96:

  # lf(n0) = ii(n0), ii(n) = ii(n0), ii(0) = 0, lf(n) = lf(n0), lf(0) = [], nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], n0 < n, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦ (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))

Rule argument

Additional information

Proof step 96 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 97:

  # lf(n0) = ii(n0), ii(0) = 0, ii(n) = ii(n0), lf(0) = [], lf(n) = lf(n0), nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], ii(m) ≠ ii(n0), n0 < n, n0 ≤ m, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0) ⊦

• Proof step 98:

  # lf(n0) = ii(n0), ii(0) = 0, ii(n) = ii(n0), lf(0) = [], lf(n) = lf(n0), nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], n0 < n, ¬ ii(m) < ii(m + 1), ¬ n0 ≤ m, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0) ⊦

Rule argument

Additional information

Proof step 97 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) Used terms: m

Proof step 98 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 99:

  # lf(n0) = ii(n0), ii(0) = 0, ii(n) = ii(n0), lf(0) = [], lf(n) = lf(n0), nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], m < n, m < n0, n0 < n, m + 1 < n, ii(m + 1) ≤ ii(m), ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m.+1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) trans-nat: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m.+1 < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 99 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 100:

  # lf(n0) = ii(n0), ii(n) = ii(n0), ii(0) = 0, lf(n) = lf(n0), lf(0) = [], nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], m + 1 < n, n0 < n, m < n0, m < n, ii(m + 1) ≤ ii(m), m ≤ m + 1 → ii(m) ≤ ii(m + 1), ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used terms: m, m + 1

Proof step 100 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 101:

  # lf(n0) = ii(n0), ii(m + 1) = ii(m), ii(n) = ii(n0), ii(0) = 0, lf(n) = lf(n0), lf(0) = [], nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], m + 1 < n, n0 < n, m < n0, m < n, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ m; (s) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ m + n; (s)

Proof step 101 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 102:

  # lf(n0) = ii(n0), nextli0(lf(m)) = [] ↔ n0 ≤ m, ii(0) = 0, ii(n) = ii(n0), ii(m + 1) = ii(m), lf(0) = [], lf(n) = lf(n0), nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], m < n, m < n0, n0 < n, m + 1 < n, ∀ n0. lf(n0) = lf(n).take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0) ⊦

Rule argument

Additional information

Used terms: m

Proof step 102 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 103:

  # lf(n0) = ii(n0), ii(m + 1) = ii(m), ii(n) = ii(n0), ii(0) = 0, lf(n) = lf(n0), lf(0) = [], nextli(lf(n0)) = lf(n0), nextli0(lf(n0)) = [], nextli0(lf(m)) ≠ [], m + 1 < n, n0 < n, m < n0, m < n, ∀ m. n0 < m → lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ lf(n).drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = lf(n).take(ii(n0)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → (n ≤ m ↔ false); (s)

Proof step 103 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m = m + n ↔ n = 0; (s) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: m

Proof step 104 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule weakening

And obtained the following new goals

• Proof step 105:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 105 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule induction

And obtained the following new goals

• Proof step 106:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: <; (wellfounded) Used terms: n

Proof step 106 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 107:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 107 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 108:

  # x = ii(n), ii(0) = 0, lf(0) = [], ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∀ m. nextli0(lf(m)) = [] ↔ n ≤ m, ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used terms: n

Proof step 108 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 109:

  # x = ii(n), ii(0) = 0, lf(0) = [], ¬(nextli0(lf(m)) = [] ↔ n ≤ m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 109 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 110:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ¬ n ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

• Proof step 132:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) ≠ [], n ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 110 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 111:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 111 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply induction

And obtained the following new goals

• Proof step 112:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, # x = ii(m) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m0. m ≤ m0 → nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(m) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0)))

• Proof step 128:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used terms: m, x, ii, lf, nextli0, nextli

Proof step 112 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 113:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ii(n) = ii(m) ∧ (m ≤ m0 → nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)) ∧ ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(m) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))

Rule argument

Additional information

Proof step 113 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 114:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, nextli0(lf(m)) = [] → (∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ii(n) = ii(m) ∧ (m ≤ m0 → nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)) ∧ ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(m) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))

Rule argument

Additional information

Used terms: m

Proof step 114 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 115:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ii(n) = ii(m) ∧ (m ≤ m0 → nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)) ∧ ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(m) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))

Rule argument

Additional information

Proof step 115 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 116:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ii(n) ≠ ii(m), m < n, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

• Proof step 117:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, m ≤ m0, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)

• Proof step 120:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ii(n1 + 1) ≠ ii(n1) + # nextli0(lf(n1)), m < n, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

• Proof step 121:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ii(m) < ii(n1 + 1), m < n, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

• Proof step 127:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], x.drop(ii(n1)).take(# nextli0(lf(n1))) ≠ nextli0(lf(n1)), m < n, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 116 from proof infinite-append-prefixnextli (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 117 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 118:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, m ≤ m0, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)

Rule argument

Additional information

Proof step 118 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 119:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, m ≤ m0, m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m)

Rule argument

Additional information

Used terms: m0

Proof step 119 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ m ≤ m; (s) ⊦ ¬ n < n; (s) ⊦ m < n → m ≤ n; (s) Used formulas: m < m0

Proof step 120 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n1

Proof step 121 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 122:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ii(m) < ii(n1 + 1), m < n, ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 122 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 123:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ii(m) < ii(n1 + 1), m < n1 + 1 → lf(n1 + 1) = lf(m) ∧ nextli0(lf(n1 + 1)) = [] ∧ ii(n1 + 1) = ii(m), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used terms: n1 + 1

Proof step 123 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 124:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ii(m) < ii(n1 + 1), m < n, ¬ n1 < m → lf(n1 + 1) = lf(m) ∧ nextli0(lf(n1 + 1)) = [] ∧ ii(n1 + 1) = ii(m), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s)

Proof step 124 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 125:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ii(m) < ii(n1 + 1), n1 < m, ¬ n1 < m → lf(n1 + 1) = lf(m) ∧ nextli0(lf(n1 + 1)) = [] ∧ ii(n1 + 1) = ii(m), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n < m ↔ false); (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m < n → n ≠ 0; (s) ⊦ m < n → ¬ n < m; (s) Used formulas: n1 < m

Proof step 125 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 126:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], n1 < n, m < n, ii(m) < ii(n1 + 1), n1 < m, n1 + 1 < n, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ m0. m < m0 → lf(m0) = lf(m) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(m), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used simplifier rules: ⊦ m.+1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) trans-nat: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m.+1 < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 126 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: n1 + 1, m

Proof step 127 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: n1

Proof step 128 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 129:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Proof step 129 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule exists right

And obtained the following new goals

• Proof step 130:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], m < n, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦ ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m

Rule argument

Additional information

Used terms: n0

Proof step 130 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 131:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(m)) = [], ¬(nextli0(lf(m0)) = [] ↔ n0 ≤ m0), m < n, ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m, ∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0, x, ii, lf, nextli0, nextli. n0 < n → # x = ii(n0) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ (∀ n. nextli0(lf(n)) = [] → (∀ m. n < m → lf(m) = lf(n) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n))) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n0 ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)) ∧ (∀ n1. ii(n1 + 1) = ii(n1) + # nextli0(lf(n1)) ∧ ¬ ii(n0) < ii(n1 + 1) ∧ x.drop(ii(n1)).take(# nextli0(lf(n1))) = nextli0(lf(n1))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → (∃ n0. ∀ m. nextli0(lf(m)) = [] ↔ n0 ≤ m) ⊦

Rule argument

Additional information

Proof step 131 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: m0

Proof step 132 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used terms: m

Proof step 133 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 134:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 < m, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∃ n0. ii(n) = ii(n0) ∧ nextli(x) = x ∧ (∀ m. (n0 ≤ m ⊃ ii(m) = ii(n0);ii(m) < ii(m + 1))), lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 134 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule weakening

And obtained the following new goals

• Proof step 135:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 < m, ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ lf(m) = lf(n0) ∧ nextli0(lf(m)) = [] ∧ ii(m) = ii(n0)

Rule argument

Additional information

Proof step 135 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule structural induction

And obtained the following new goals

• Proof step 136:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 < m0.+1, ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ x, ii, n, lf, nextli0, n0, nextli. # x = ii(n) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ n0 < m0 ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n)) ∧ (∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0) ⊦ lf(m0.+1) = lf(n0) ∧ nextli0(lf(m0.+1)) = [] ∧ ii(m0.+1) = ii(n0)

Rule argument

Additional information

Used simplifier rules: Nat freely generated by 0, +1; ⊦ ¬ n < 0; (s)

Proof step 136 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 137:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 ≤ m0, ∀ x, ii, n, lf, nextli0, n0, nextli. # x = ii(n) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ n0 < m0 ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n)) ∧ (∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ lf(m0 + 1) = lf(n0) ∧ nextli0(lf(m0 + 1)) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m.+1 = m + 1; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n + 1 ↔ ¬ n < m; (s)

Proof step 137 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 138:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 ≤ m0, # x = ii(n) ∧ ii(0) = 0 ∧ lf(0) = [] ∧ nextli0(lf(n0)) = [] ∧ n0 < m0 ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n)) ∧ (∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0))) ∧ (∀ n0. lf(n0) = x.take(ii(n0))) → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ lf(m0 + 1) = lf(n0) ∧ nextli0(lf(m0 + 1)) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used terms: x, ii, n, lf, nextli0, n0, nextli

Proof step 138 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 139:

  # x = ii(n), ii(0) = 0, lf(0) = [], nextli0(lf(n0)) = [], n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ lf(m0 + 1) = lf(n0) ∧ nextli0(lf(m0 + 1)) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Proof step 139 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 140:

  # x = ii(n), ii(0) = 0, lf(0) = [], lf(m0 + 1) = nextli(lf(m0)), nextli0(lf(n0)) = [], n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ lf(m0 + 1) = lf(n0) ∧ nextli0(lf(m0 + 1)) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used terms: m0

Proof step 140 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 141:

  # x = ii(n), ii(0) = 0, lf(m0 + 1) = nextli(lf(m0)), lf(0) = [], nextli0(lf(n0)) = [], n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Proof step 141 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 142:

  # x = ii(n), ii(0) = 0, lf(0) = [], lf(m0 + 1) = nextli(lf(m0)), lf((m0 + 1) + 1) = nextli(lf(m0 + 1)), nextli0(lf(n0)) = [], n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used terms: m0 + 1

Proof step 142 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 143:

  # x = ii(n), ii(0) = 0, lf(m0 + 1) = nextli(lf(m0)), lf(0) = [], lf(2 + m0) = nextli(nextli(lf(m0))), nextli0(lf(n0)) = [], n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic

Proof step 143 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 144:

  # x = ii(n), ii(0) = 0, ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), lf(2 + m0) = nextli(nextli(lf(m0))), lf(0) = [], lf(m0 + 1) = nextli(lf(m0)), nextli0(lf(n0)) = [], x.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), n0 ≤ m0, ¬ ii(n) < ii(m0 + 1), n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used terms: m0

Proof step 144 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 145:

  # x = ii(n), ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), ii(0) = 0, lf(m0 + 1) = nextli(lf(m0)), lf(0) = [], lf(2 + m0) = nextli(nextli(lf(m0))), nextli0(lf(n0)) = [], x.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), n0 ≤ m0, ii(m0 + 1) ≤ ii(n), n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)

Proof step 145 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 146:

  # x = ii(n), ii(0) = 0, ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), lf(2 + m0) = nextli(nextli(lf(m0))), lf(0) = [], lf(m0 + 1) = nextli(lf(m0)), nextli(lf(m0)) = lf(m0) + nextli0(lf(m0)), nextli0(lf(n0)) = [], x.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), ii(m0 + 1) ≤ ii(n), n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ nextli(lf(m0)) = lf(n0) ∧ nextli0(nextli(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Used terms: lf(m0)

Proof step 146 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 147:

  # x = ii(n), ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), ii(0) = 0, lf(m0 + 1) = lf(m0) + nextli0(lf(m0)), lf(0) = [], lf(2 + m0) = nextli(lf(m0) + nextli0(lf(m0))), nextli0(lf(n0)) = [], x.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), n0 ≤ m0, ii(m0 + 1) ≤ ii(n), n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ n0. lf(n0) = x.take(ii(n0)) ⊦ lf(m0) + nextli0(lf(m0)) = lf(n0) ∧ nextli0(lf(m0) + nextli0(lf(m0))) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Proof step 147 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 148:

  # x = ii(n), ii(0) = 0, ii(m0 + 1) = ii(m0) + # nextli0(lf(m0)), lf(2 + m0) = nextli(lf(m0 + 1)), lf(0) = [], lf(m0 + 1) = lf(m0) + nextli0(lf(m0)), nextli0(lf(n0)) = [], x.drop(ii(m0)).take(# nextli0(lf(m0))) = nextli0(lf(m0)), ii(m0 + 1) ≤ ii(n), n0 ≤ m0, n0 < m0 → lf(m0) = lf(n0) ∧ nextli0(lf(m0)) = [] ∧ ii(m0) = ii(n0), ∀ n0. lf(n0) = x.take(ii(n0)), ∀ n0. ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)) ∧ ¬ ii(n) < ii(n0 + 1) ∧ x.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ lf(m0 + 1) = lf(n0) ∧ nextli0(lf(m0 + 1)) = [] ∧ ii(m0 + 1) = ii(n0)

Rule argument

Additional information

Proof step 148 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule cut formula

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) ⊦ m ≤ m; (s) ⊦ ¬ n < n; (s) ⊦ x.take(0) = []; (s) ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ # [] = 0; (s) ⊦ n + 0 = n; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m < n → m ≤ n; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m < n → n ≠ 0; (s) Used formulas: n0 < m0

Proof step 149 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 150:

  ii(0) = 0, lf(0) = [], ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n0. lf(n0) = nf.take(ii(n0)) ⊦ ∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1)

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜nf⌝ .take(n) = nf.take(n); (s) ⊦ ⌜nf⌝ .drop(n) = ⌜nf.drop(n)⌝ ; (s) ⊦ ¬ ∞ < n∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ finp(σ) ↔ ¬(∃ nf. ⌜nf⌝ = σ); (ss)

Proof step 150 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 151:

  ii(0) = 0, lf(0) = [], ∀ n0. lf(n0) = nf.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1) ⊦ ∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1)

Rule argument

Additional information

Used terms: n1

Proof step 151 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 152:

  ii(0) = 0, lf(0) = [], ii(m) < ii(m + 1), n1 < ii(m + 1), ii(m) ≤ n1, ∀ n0. lf(n0) = nf.take(ii(n0)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ nf.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1)

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 152 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic quantifier closing applied rule exists right

And closed the goal!

Rule argument

Additional information

Used terms: m

Proof step 153 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule simplifier

And obtained the following new goals

• Proof step 154:

  ii(0) = 0, lf(0) = [], lf(n2) ≠ σ.take(ii(n2)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦ ¬ # σ < ⌜ii(n0 + 1)⌝ ∧ σ.take(ii(n0 + 1)) = nextli(σ.take(ii(n0))) ∧ (# σ = ⌜ii(n0)⌝ ⊃ ii(n0) = ii(n0 + 1);ii(n0) < ii(n0 + 1)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1)));∃ m. ii(m) ≤ n1 ∧ n1 < ii(m + 1))

Rule argument

Additional information

Proof step 154 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule weakening

And obtained the following new goals

• Proof step 155:

  ii(0) = 0, lf(0) = [], lf(n2) ≠ σ.take(ii(n2)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Proof step 155 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule structural induction

And obtained the following new goals

• Proof step 156:

  ii(0) = 0, lf(0) = [], lf(n0.+1) ≠ σ.take(ii(n0.+1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ ii, lf, σ, n, nextli0, nextli. ¬ ( ii(0) = 0 ∧ lf(0) = [] ∧ lf(n0) ≠ σ.take(ii(n0)) ∧ (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ∧ (∀ x0. nextli(x0) = x0 + nextli0(x0)) ∧ (∀ n. lf(n + 1) = nextli(lf(n))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)))) ⊦

Rule argument

Additional information

Used simplifier rules: Nat freely generated by 0, +1; ⊦ σ.take(0) = []; (s)

Proof step 156 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 157:

  ii(0) = 0, lf(0) = [], lf(n0 + 1) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ ii0, lf0, σ0, n1, nextli1, nextli2. ii0(0) ≠ 0 ∨ lf0(0) ≠ [] ∨ lf0(n0) = σ0.take(ii0(n0)) ∨ ¬ (finp(σ0) ⊃ # σ0 = ⌜ii0(n1)⌝ ∧ (∀ m. n1 ≤ m → nextli1(lf0(m)) = [] ∧ ii0(m) = ii0(n1));∀ n. ∃ m. ii0(m) ≤ n ∧ n < ii0(m + 1)) ∨ ¬(∀ x0. nextli2(x0) = x0 + nextli1(x0)) ∨ ¬(∀ n. lf0(n + 1) = nextli2(lf0(n))) ∨ ¬(∀ m, n. m ≤ n → ii0(m) ≤ ii0(n)) ∨ ¬ (∀ n. ii0(n + 1) = ii0(n) + # nextli1(lf0(n)) ∧ ¬ # σ0 < ⌜ii0(n + 1)⌝ ∧ σ0.drop(ii0(n)).take(# nextli1(lf0(n))) = nextli1(lf0(n))) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m.+1 = m + 1; (s)

Proof step 157 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 158:

  ii(0) = 0, lf(0) = [], lf(n0 + 1) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ii(0) ≠ 0 ∨ lf(0) ≠ [] ∨ lf(n0) = σ.take(ii(n0)) ∨ ¬ (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)) ∨ ¬(∀ x0. nextli(x0) = x0 + nextli0(x0)) ∨ ¬(∀ n. lf(n + 1) = nextli(lf(n))) ∨ ¬(∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∨ ¬(∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n))) ⊦

Rule argument

Additional information

Used terms: ii, lf, σ, n, nextli0, nextli

Proof step 158 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 159:

  ii(0) = 0, lf(0) = [], lf(n0) = σ.take(ii(n0)), lf(n0 + 1) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Proof step 159 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 160:

  ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), lf(n0 + 1) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used terms: n0

Proof step 160 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 161:

  ii(0) = 0, lf(n0 + 1) = nextli(lf(n0)), lf(0) = [], lf(n0) = σ.take(ii(n0)), nextli(lf(n0)) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Proof step 161 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 162:

  ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), nextli(lf(n0)) ≠ σ.take(ii(n0 + 1)), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used terms: lf(n0)

Proof step 162 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 163:

  ii(0) = 0, ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), lf(n0 + 1) = nextli(lf(n0)), lf(0) = [], lf(n0) = σ.take(ii(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), nextli(lf(n0)) ≠ σ.take(ii(n0 + 1)), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used terms: n0

Proof step 163 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 164:

  ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), nextli(lf(n0)) ≠ σ.take(ii(n0 + 1)), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Proof step 164 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 165:

  ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x(n) = y(n))

• Proof step 166:

  ii(0) = 0, ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), lf(n0 + 1) = nextli(lf(n0)), lf(0) = [], lf(n0) = σ.take(ii(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), # nextli(lf(n0)) ≠ # σ.take(ii(n0 + 1)) ∨ (∃ n. ¬(n < # nextli(lf(n0)) → nextli(lf(n0))(n) = σ.take(ii(n0 + 1))(n))) ⊦

Rule argument

Additional information

Used terms: nextli(lf(n0)), σ.take(ii(n0 + 1))

Proof step 165 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 166 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 167:

  ii(n0 + 1) = ii(n0) + # nextli0(lf(n0)), ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0 + 1)⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), # nextli(lf(n0)) ≠ ii(n0 + 1) ∨ ¬(n1 < # nextli(lf(n0)) → nextli(lf(n0))(n1) = σ(n1)) ⊦

Rule argument

Additional information

Used simplifier rules: m < n, ¬ # σ < ⌜n⌝ ⊦ σ.take(n)(m) = σ(m); (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ¬ # σ < ⌜n⌝ ⊦ # σ.take(n) = n; (s)

Proof step 167 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 168:

  ii(0) = 0, lf(n0 + 1) = nextli(lf(n0)), lf(0) = [], lf(n0) = σ.take(ii(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0) + # nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), # nextli(lf(n0)) ≠ ii(n0) + # nextli0(lf(n0)) ∨ ¬(n1 < # nextli(lf(n0)) → nextli(lf(n0))(n1) = σ(n1)) ⊦

Rule argument

Additional information

Proof step 168 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 169:

  ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = nextli(lf(n0)), nextli(lf(n0)) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), # nextli(lf(n0)) ≠ ii(n0) + # nextli0(lf(n0)) ∨ ¬(n1 < # nextli(lf(n0)) → nextli(lf(n0))(n1) = σ(n1)) ⊦

Rule argument

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s)

Proof step 169 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 170:

  ii(0) = 0, lf(n0 + 1) = lf(n0) + nextli0(lf(n0)), lf(0) = [], lf(n0) = σ.take(ii(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), #(lf(n0) + nextli0(lf(n0))) ≠ ii(n0) + # nextli0(lf(n0)) ∨ ¬(n1 < #(lf(n0) + nextli0(lf(n0))) → (lf(n0) + nextli0(lf(n0)))(n1) = σ(n1)) ⊦

Rule argument

Additional information

Proof step 170 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 171:

  ii(0) = 0, lf(n0) = σ.take(ii(n0)), lf(0) = [], lf(n0 + 1) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), # lf(n0) ≠ ii(n0) ∨ ¬(n1 < # lf(n0) + # nextli0(lf(n0)) → lf(n0 + 1)(n1) = σ(n1)) ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ #(x + y) = # x + # y; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s)

Proof step 171 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 172:

  ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x(n) = y(n))

• Proof step 173:

  # lf(n0) = # σ.take(ii(n0)), ii(0) = 0, lf(n0 + 1) = lf(n0) + nextli0(lf(n0)), lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ n. n < # lf(n0) → lf(n0)(n) = σ.take(ii(n0))(n), # lf(n0) ≠ ii(n0) ∨ ¬(n1 < # lf(n0) + # nextli0(lf(n0)) → lf(n0 + 1)(n1) = σ(n1)) ⊦

Rule argument

Additional information

Used terms: lf(n0), σ.take(ii(n0))

Proof step 172 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 173 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 174:

  # lf(n0) = ii(n0), ii(0) = 0, lf(n0 + 1) = lf(n0) + nextli0(lf(n0)), lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), lf(n0 + 1)(n1) ≠ σ(n1), n1 < ii(n0) + # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n2. n2 < ii(n0) → lf(n0)(n2) = σ(n2), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic m < n, ¬ # σ < ⌜n⌝ ⊦ σ.take(n)(m) = σ(m); (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ m + n < m; (s) ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ # x = 0 ↔ x = []; (s) lels-trans: ⊦ ¬ n∞1 < n∞ ∧ n∞1 < n∞2 → n∞ < n∞2; (forward) from specification nat-inf lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ¬ # σ < ⌜n⌝ ⊦ # σ.take(n) = n; (s)

Proof step 174 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 175:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], lf(n0 + 1) = lf(n0) + nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), lf(n0 + 1)(n1) ≠ σ(n1), n1 < ii(n0) + # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , n1 < ii(n0) → lf(n0)(n1) = σ(n1), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used terms: n1

Proof step 175 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 176:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), (lf(n0) + nextli0(lf(n0)))(n1) ≠ σ(n1), n1 < ii(n0) + # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , n1 < ii(n0) → lf(n0)(n1) = σ(n1), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Proof step 176 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 177:

  ⊦ n < # x → (x + y)(n) = x(n)

• Proof step 178:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), (lf(n0) + nextli0(lf(n0)))(n1) ≠ σ(n1), n1 < ii(n0) + # nextli0(lf(n0)), ¬ n1 < # lf(n0), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , n1 < ii(n0) → lf(n0)(n1) = σ(n1), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n → n ≠ 0; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ ¬ n < n; (s) Used terms: lf(n0), nextli0(lf(n0)), n1

Proof step 177 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 178 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 179:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), nextli0(lf(n0))(n1 - ii(n0)) ≠ σ(n1), nextli0(lf(n0)) ≠ [], n1 < ii(n0) + # nextli0(lf(n0)), ii(n0) ≤ n1, ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ n → (n < m ↔ false); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ # x = 0 ↔ x = []; (s) ⊦ m < m + n ↔ n ≠ 0; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ ¬ n < # x → (x + y)(n) = y(n - # x); (s)

Proof step 179 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 180:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], n1 = n2 + ii(n0), σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), nextli0(lf(n0))(n2) ≠ σ(n1), nextli0(lf(n0)) ≠ [], n1 < ii(n0) + # nextli0(lf(n0)), ii(n0) ≤ n1, ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used simplifier rules: n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: n1, ii(n0), n2

Proof step 180 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 181:

  # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], σ.drop(ii(n0)).take(# nextli0(lf(n0))) = nextli0(lf(n0)), nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m ≤ m + n; (s)

Proof step 181 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 182:

  ⊦ x = y ↔ # x = # y ∧ (∀ n. n < # x → x(n) = y(n))

• Proof step 183:

  # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. n < # σ.drop(ii(n0)).take(# nextli0(lf(n0))) → σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n) = nextli0(lf(n0))(n) ⊦

Rule argument

Additional information

Used terms: σ.drop(ii(n0)).take(# nextli0(lf(n0))), nextli0(lf(n0))

Proof step 182 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 183 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 184:

  # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), # lf(n0) = ii(n0), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. n < # nextli0(lf(n0)) → σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n) = nextli0(lf(n0))(n) ⊦

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic

Proof step 184 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 185:

  # lf(n0) = ii(n0), # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , n2 < # nextli0(lf(n0)) → σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n2) = nextli0(lf(n0))(n2), (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used terms: n2

Proof step 185 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 186:

  # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), # lf(n0) = ii(n0), σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n2) = nextli0(lf(n0))(n2), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Proof step 186 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 187:

  m < n, ¬ # σ < ⌜n⌝ ⊦ σ.take(n)(m) = σ(m)

• Proof step 188:

  # lf(n0) = ii(n0), # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n2) = nextli0(lf(n0))(n2), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦ n2 < # nextli0(lf(n0)) ∧ ¬ # σ.drop(ii(n0)) < ⌜# nextli0(lf(n0))⌝

• Proof step 191:

  # lf(n0) = ii(n0), # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), σ.drop(ii(n0))(n2) = nextli0(lf(n0))(n2), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ.drop(ii(n0)) < ⌜# nextli0(lf(n0))⌝ , ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ x0. nextli(x0) = x0 + nextli0(x0), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)) ⊦

Rule argument

Additional information

Used terms: σ.drop(ii(n0)), # nextli0(lf(n0)), n2

Proof step 187 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 188 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 189:

  # σ.drop(ii(n0)).take(# nextli0(lf(n0))) = # nextli0(lf(n0)), # lf(n0) = ii(n0), σ.drop(ii(n0)).take(# nextli0(lf(n0)))(n2) = nextli0(lf(n0))(n2), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), # σ.drop(ii(n0)) < ⌜# nextli0(lf(n0))⌝ , ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Proof step 189 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 190:

  ⊦ ¬ # σ < ⌜n⌝ ∧ finp(σ) → # σ.drop(n) = ⌜(# σ).n - n⌝

Rule argument

Additional information

Used simplifier rules: m < n, ¬ # σ < ⌜n⌝ ⊦ σ.take(n)(m) = σ(m); (s) ⊦ ¬ # σ < ⌜n⌝ → (# σ.drop(n) < ⌜n0⌝ ↔ # σ < ⌜n + n0⌝ ); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ¬ # σ < ⌜n⌝ ⊦ # σ.take(n) = n; (s) ⊦ finp(σ) ↔ (∃ x. ⌜x⌝ = σ); (as) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ ⌜x⌝ .drop(n) = ⌜x.drop(n)⌝ ; (s) ⊦ ⌜x⌝ (n) = x(n); (s) ⊦ ⌜n⌝ .n = n; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < n → ⌜m⌝ < ⌜n⌝ + n∞0; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜n⌝ < ⌜m⌝ + ⌜n0⌝ ↔ n < m + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf lsle-trans: ⊦ n∞ < n∞1 ∧ ¬ n∞2 < n∞1 → n∞ < n∞2; (forward) from specification nat-inf ⊦ ¬ n∞ < n∞; (s) lels-trans: ⊦ ¬ n∞1 < n∞ ∧ n∞1 < n∞2 → n∞ < n∞2; (forward) from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ ¬ m + n < m; (s) Used terms: σ, ii(n0)

Proof step 190 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 191 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 192:

  # lf(n0) = ii(n0), σ.drop(ii(n0))(n2) = nextli0(lf(n0))(n2), ii(0) = 0, lf(0) = [], nextli0(lf(n0))(n2) ≠ σ(n2 + ii(n0)), nextli0(lf(n0)) ≠ [], n2 < # nextli0(lf(n0)), ¬ # σ.drop(ii(n0)) < ⌜# nextli0(lf(n0))⌝ , ¬ # σ < ⌜ii(n0)⌝ + ⌜# nextli0(lf(n0))⌝ , (finp(σ) ⊃ # σ = ⌜ii(n)⌝ ∧ (∀ m. n ≤ m → nextli0(lf(m)) = [] ∧ ii(m) = ii(n));∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1)), ∀ n. ii(n + 1) = ii(n) + # nextli0(lf(n)) ∧ ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.drop(ii(n)).take(# nextli0(lf(n))) = nextli0(lf(n)), ∀ m, n. m ≤ n → ii(m) ≤ ii(n), ∀ n. lf(n + 1) = nextli(lf(n)), ∀ x0. nextli(x0) = x0 + nextli0(x0) ⊦

Rule argument

Additional information

Used simplifier rules: ¬ # σ < ⌜n⌝ ⊦ # σ.take(n) = n; (s)

Proof step 192 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 193:

  ⊦ ¬ # σ < ⌜n⌝ ∧ finp(σ) → # σ.drop(n) = ⌜(# σ).n - n⌝

Rule argument

Additional information

Used simplifier rules: ⊦ finp(σ) ↔ (∃ x. ⌜x⌝ = σ); (as) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ ⌜x⌝ .drop(n) = ⌜x.drop(n)⌝ ; (s) ⊦ ⌜n⌝ .n = n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) c: ⊦ m + n = n + m; from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) m + m0 < # x ⊦ x.drop(m)(m0) = x(m + m0); (s) ⊦ ⌜x⌝ (n) = x(n); (s) lels-trans: ⊦ ¬ n∞1 < n∞ ∧ n∞1 < n∞2 → n∞ < n∞2; (forward) from specification nat-inf ⊦ ⌜n⌝ + ⌜m⌝ < ⌜n0⌝ ↔ n + m < n0; (s) ⊦ ¬ m + n < m; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf ⊦ ¬ # σ < ⌜n⌝ → (# σ.drop(n) < ⌜n0⌝ ↔ # σ < ⌜n + n0⌝ ); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ finp(σ) ↔ ¬(∃ nf. ⌜nf⌝ = σ); (ss) ⊦ ⌜nf⌝ .drop(n) = ⌜nf.drop(n)⌝ ; (s) ⊦ nf.drop(n)(m) = nf(m + n); (s) ⊦ ⌜nf⌝ (n) = nf(n); (s) Used terms: σ, ii(n0)

Proof step 193 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma

Proof step 194 from proof infinite-append-prefixnextli (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 195:

  ∀ x. x ⊑ nextli(x) ⊦ ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) ), ∃ y. nextli(x) = x + y

Rule argument

Additional information

Proof step 195 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 196:

  x ⊑ nextli(x) ⊦ ∃ y. nextli(x) = x + y, ∃ σ, ii. ii(0) = 0 ∧ (∀ n. ¬ # σ < ⌜ii(n + 1)⌝ ∧ σ.take(ii(n + 1)) = nextli(σ.take(ii(n))) ∧ (# σ = ⌜ii(n)⌝ ⊃ ii(n) = ii(n + 1);ii(n) < ii(n + 1))) ∧ (∀ m, n. m ≤ n → ii(m) ≤ ii(n)) ∧ (finp(σ) ⊃ ∃ n. # σ = ⌜ii(n)⌝ ∧ ⌜nextli(σ.l)⌝ = σ ∧ (∀ m. (n ≤ m ⊃ ii(m) = ii(n);ii(m) < ii(m + 1))) ;∀ n. ∃ m. ii(m) ≤ n ∧ n < ii(m + 1) )

Rule argument

Additional information

Used terms: x

Proof step 196 from proof infinite-append-prefixnextli (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 197:

  ⊦ x ⊑ y ↔ (∃ z. x + z = y)

Rule argument

Additional information

Used simplifier rules: ⊦ # x = # z → (x + y = z + y0 ↔ x = z ∧ y = y0); (ws) a: ⊦ (x + y) + z = x + y + z; from specification list Used terms: nextli(x), x

Proof step 197 from proof infinite-append-prefixnextli (previous step) (back to tree)

A spec-lemma