Proof step 1 from proof next-proper-permutation (conclusion) (back to tree)

User applied rule call right

And obtained the following new goals

• Proof step 2:

  ar = ar0 ⊦ ⟨let ghostar = ar in if # ar = 0 then hasNext := false else let i = (# ar)-1 in {while i > 0 ∧ ar[i -1] ≥ ar[i] do {/* next-proper-permutation: invariant i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))) wfbound i */; i := i -1}; if i ≤ 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i +1; j := j -1}}}}; hasNext := true}}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar))

Rule argument

Additional information

Used simplifier rules: next: ⊦ ;

Proof step 2 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 3:

  ar = ar0 ⊦ ⟨let ghostar = ar in if ar = [] then hasNext := false else let i = (# ar)-1 in {while i ≠ 0 ∧ ar[i -1] ≥ ar[i] do {/* next-proper-permutation: invariant i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))) wfbound i */; i := i -1}; if i = 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true}}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ m ≤ 0 ↔ m = 0; (s) ⊦ m +1 = m + 1; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ m > n ↔ n < m; (s)

Proof step 3 from proof next-proper-permutation (previous step) (back to tree)

User applied rule let right

And obtained the following new goals

• Proof step 4:

  ar = ar0, ghostar = ar ⊦ ⟨if ar = [] then hasNext := false else let i = (# ar)-1 in {while i ≠ 0 ∧ ar[i -1] ≥ ar[i] do {/* next-proper-permutation: invariant i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))) wfbound i */; i := i -1}; if i = 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true}}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Proof step 4 from proof next-proper-permutation (previous step) (back to tree)

User applied rule if right

And obtained the following new goals

• Proof step 5:

  ar = [], ar = ar0, ghostar = ar ⊦ ⟨hasNext := false⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

• Proof step 9:

  ar = ar0, ghostar = ar, ar ≠ [] ⊦ ⟨let i = (# ar)-1 in {while i ≠ 0 ∧ ar[i -1] ≥ ar[i] do {/* next-proper-permutation: invariant i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))) wfbound i */; i := i -1}; if i = 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true}}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Proof step 5 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 6:

  ar = ar0, ar = [], ghostar = ar ⊦ (false ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Proof step 6 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 7:

  ¬ max([]) ⊦

Rule argument

Additional information

Proof step 7 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 8:

  ⊦ max(ar1) ↔ (∀ ar2. perm(ar1, ar2) → ar2 ≤ ar1)

Rule argument

Additional information

Used simplifier rules: lexicographic-base1: ⊦ [] ≤ []; ⊦ perm([], y) ↔ y = []; (s) Used terms: []

Proof step 8 from proof next-proper-permutation (previous step) (back to tree)

Lemma maximum-permutation

Proof step 9 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule let right

And obtained the following new goals

• Proof step 10:

  ar = ar0, ghostar = ar, i = (# ar)-1, # ar ≠ 0, ar ≠ [] ⊦ ⟨while i ≠ 0 ∧ ar[i -1] ≥ ar[i] do {/* next-proper-permutation: invariant i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))) wfbound i */; i := i -1}; if i = 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

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

Proof step 10 from proof next-proper-permutation (previous step) (back to tree)

Heuristic annotation applied rule annotation right

And obtained the following new goals

• Proof step 11:

  ar = ar0, ghostar = ar, i = (# ar)-1, # ar ≠ 0, ar ≠ [] ⊦ i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i)))

• Proof step 16:

  ar = ar0, ghostar = ar, i = i0, i1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), ar[i -1] ≥ ar[i], i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ ⟨i := i -1⟩ ((i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i)))) ∧ i < i0)

• Proof step 23:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ ⟨if i = 0 then hasNext := false else {let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true}⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

Rule argument

Additional information

Used simplifier rules: ⊦ n -1 = n - 1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m < n → ¬ n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used formulas: i < # ar ∧ ordered≤(rev(subarray(ar, i, # ar - i))), i = i

Proof step 11 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 12:

  ar ≠ [], ¬ ordered≤(rev(subarray(ar, # ar - 1, # ar - (# ar - 1)))) ⊦

Rule argument

Additional information

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

Proof step 12 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 13:

  # ar = m + 1, # ar ≠ 0, ar ≠ [], ¬ ordered≤(rev(subarray(ar, m, # ar - m))) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # ar, m

Proof step 13 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 14:

  # ar = m + 1, ar ≠ [], ¬ ordered≤(rev(subarray(ar, m, 1))) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m + 1 = n → n - m = 1; (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)

Proof step 14 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 15:

  ⊦ # ar ≤ 1 → ordered≤(ar)

Rule argument

Additional information

Used simplifier rules: ⊦ # rev(x) = # x; (s) ⊦ # subarray(ar, m, n) = n; (s) Used terms: rev(subarray(ar, m, 1))

Proof step 15 from proof next-proper-permutation (previous step) (back to tree)

Lemma ordered-size-smaller-one

Proof step 16 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 17:

  ar = ar0, ghostar = ar, i = i0, i1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), ar[i -1] ≥ ar[i], i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ (i -1 < # ar ∧ ordered≤(rev(subarray(ar, i -1, # ar - i -1)))) ∧ i -1 < i0

Rule argument

Additional information

Proof step 17 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 18:

  ar ≠ [], i0 ≠ 0, i0 < # ar, ordered≤(rev(subarray(ar, i0, # ar - i0))), ar[i0] ≤ ar[i0 - 1], ¬ ordered≤(rev(subarray(ar, i0 - 1, # ar - (i0 - 1)))) ⊦

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 ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n -1 = n - 1; (s) ⊦ m < n → ¬ n < m; (s) ⊦ a < b → (b < a ↔ false); (ss) ⊦ n ≥ m ↔ m ≤ n; (s)

Proof step 18 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 19:

  i0 = m + 1, ar ≠ [], i0 ≠ 0, i0 < # ar, ordered≤(rev(subarray(ar, i0, # ar - i0))), ar[i0] ≤ ar[m], ¬ ordered≤(rev(subarray(ar, m, # ar - m))) ⊦

Rule argument

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: i0, m

Proof step 19 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 20:

  ar ≠ [], m + 1 < # ar, ordered≤(rev(subarray(ar, m + 1, # ar - m + 1))), ar[m + 1] ≤ ar[m], ¬ ordered≤(rev(subarray(ar, m, # ar - 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 + 1 ≠ 0; (s)

Proof step 20 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 21:

  # ar = n0 + m + 1, ar ≠ [], m + 1 < # ar, ordered≤(rev(subarray(ar, m + 1, n0))), ar[m + 1] ≤ ar[m], m + 1 ≤ # ar, ¬ ordered≤(rev(subarray(ar, m, # ar - m))) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # ar, m + 1, n0

Proof step 21 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 22:

  # ar = n0 + m + 1, ar ≠ [], n0 ≠ 0, m < # ar, m + 1 < # ar, ordered≤(rev(subarray(ar, m + 1, n0))), ar[m + 1] ≤ ar[m], ¬ ordered≤(rev(subarray(ar, m, # ar - 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 ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 22 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ordered-step-down: ⊦ # ar0 = (n0 + 1) + m ∧ ordered≤(rev(subarray(ar0, m + 1, n0))) ∧ ar0[m + 1] ≤ ar0[m] → ordered≤(rev(subarray(ar0, m, n0 + 1))); ⊦ m < n → m ≤ n; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ m < n → n ≠ 0; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ m + n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # ar, m, n

Proof step 23 from proof next-proper-permutation (previous step) (back to tree)

Heuristic conditional right split applied rule if right

And obtained the following new goals

• Proof step 24:

  ar = ar0, ghostar = ar, i = 0, i1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ ⟨hasNext := false⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

• Proof step 25:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ ⟨let j = (# ar)-1 in {while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

Rule argument

Additional information

Proof step 24 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And closed the goal!

Rule argument

Additional information

Used simplifier rules: descending-order-is-max-permuted: ⊦ ordered≤(rev(ar)) → max(ar); ⊦ m - 0 = m; (s) ⊦ subarray(ar, 0, # ar) = ar; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s)

Proof step 25 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule let right

And obtained the following new goals

• Proof step 26:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, j = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar ⊦ ⟨while ar[j] ≤ ar[i -1] do {/* next-proper-permutation: invariant j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]) wfbound j */; j := j -1}; let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

Rule argument

Additional information

Proof step 26 from proof next-proper-permutation (previous step) (back to tree)

Heuristic annotation applied rule annotation right

And obtained the following new goals

• Proof step 27:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, j = j0, j1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, j < # ar, i -1 < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≤ j, ar[j] ≤ ar[i -1], i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar, ∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1] ⊦ ⟨j := j -1⟩ ( (j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1])) ∧ j < j0), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

• Proof step 36:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, j1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, i < # ar, j < # ar, i -1 < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≤ j, ¬ ar[j] ≤ ar[i -1], i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar, ∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1] ⊦ ⟨let temp = ar[i -1] in {ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

Rule argument

Additional information

Used simplifier rules: ⊦ n -1 = n - 1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m > n ↔ n < m; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n → n ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < n → ¬ n < m; (s) ⊦ a < b → (b < a ↔ false); (ss) ⊦ ¬ a < a; (s) n0 ≤ n ⊦ m ≤ n - n0 ↔ m + n0 ≤ n; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) Used formulas: j < # ar ∧ i ≤ j ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1]), j = j

Proof step 27 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 28:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, j = j0, j1 = (# ar)-1, # ar ≠ 0, ar ≠ [], i ≠ 0, j ≠ 0, i -1 < # ar, j < # ar, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), ar[j] ≤ ar[i -1], i ≤ j, i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar, ∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1] ⊦ i ≠ 0 ∧ ar[i -1] ≥ ar[i], (j -1 < # ar ∧ i ≤ j -1 ∧ i ≠ 0 ∧ ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n > j -1 ∧ n < # ar → ar[n] ≤ ar[i - 1])) ∧ j -1 < j0

Rule argument

Additional information

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

Proof step 28 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 29:

  ar ≠ [], i ≠ 0, j0 ≠ 0, ar[j0] < ar[i], ar[i - 1] < ar[i], j0 < # ar, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), ar[j0] ≤ ar[i - 1], i ≤ j0, ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[i - 1] ⊦ i < j0 ∧ (¬ n < j0 ∧ n < # ar → ar[n] ≤ ar[i - 1])

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ m < n → n ≠ 0; (s) 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 ≥ m ↔ m ≤ n; (s) ⊦ n -1 = n - 1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m > n ↔ n < m; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) n0 ≤ n ⊦ m ≤ n - n0 ↔ m + n0 ≤ n; (s) ⊦ m < n → ¬ n < m; (s) ⊦ a < b → (b < a ↔ false); (ss)

Proof step 29 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 30:

  i = m + 1, ar ≠ [], i ≠ 0, j0 ≠ 0, i < # ar, j0 < # ar, ar[m] < ar[i], ar[j0] < ar[i], ordered≤(rev(subarray(ar, i, # ar - i))), i ≤ j0, ar[j0] ≤ ar[m], ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦ i < j0 ∧ (¬ n < j0 ∧ n < # ar → ar[n] ≤ ar[m])

Rule argument

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: i, m

Proof step 30 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 31:

  ar ≠ [], ar[j0] < ar[m + 1], m < j0, j0 < # ar, ar[m] < ar[m + 1], m < # ar, m + 1 < # ar, ordered≤(rev(subarray(ar, m + 1, # ar - m + 1))), ar[j0] ≤ ar[m], ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦ m + 1 < j0 ∧ (¬ n < j0 ∧ n < # ar → ar[n] ≤ ar[m])

Rule argument

Additional information

Used simplifier rules: ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 31 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 32:

  # ar = n0 + m + 1, ar ≠ [], m + 1 < # ar, m < # ar, ar[m] < ar[m + 1], j0 < # ar, m < j0, ar[j0] < ar[m + 1], ordered≤(rev(subarray(ar, m + 1, n0))), ar[j0] ≤ ar[m], m + 1 ≤ # ar, ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦ m + 1 < j0 ∧ (¬ n < j0 ∧ n < # ar → ar[n] ≤ ar[m])

Rule argument

Additional information

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

Proof step 32 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 33:

  # ar = n0 + m + 1, ar ≠ [], n0 ≠ 0, ar[j0] < ar[m + 1], m < j0, j0 < # ar, ar[m] < ar[m + 1], m + 1 < # ar, m < # ar, ordered≤(rev(subarray(ar, m + 1, n0))), j0 ≤ n0 + m, ar[j0] ≤ ar[m], ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦ m + 1 < j0 ∧ (¬ n < j0 ∧ n < # ar → ar[n] ≤ ar[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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 33 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 34:

  # ar = n0 + m + 1, ar ≠ [], n0 ≠ 0, n < # ar, m < # ar, m + 1 < # ar, ar[m] < ar[m + 1], j0 < # ar, m < j0, ar[j0] < ar[m + 1], ordered≤(rev(subarray(ar, m + 1, n0))), ar[j0] ≤ ar[m], j0 ≤ n0 + m, ¬ n < j0, ¬ ar[n] ≤ ar[m], ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ a < a; (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)

Proof step 34 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 35:

  # ar = n0 + m + 1, ar ≠ [], n0 ≠ 0, ar[j0] < ar[m + 1], m < j0, j0 < # ar, ar[m] < ar[m + 1], m + 1 < # ar, m < # ar, n < # ar, ar[m] < ar[n], ar[j0] < ar[n], m < n, ordered≤(rev(subarray(ar, m + 1, n0))), j0 ≤ n0 + m, n ≤ n0 + m, ar[j0] ≤ ar[m], j0 ≤ n, ∀ n. j0 < n ∧ n < # ar → ar[n] ≤ ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ 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) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 35 from proof next-proper-permutation (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) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≤ n → (n ≤ m ↔ m = n); (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] ⊦ ¬ a < a; (s) Used terms: n

Proof step 36 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule let right

And obtained the following new goals

• Proof step 37:

  ar = ar0, ghostar = ar, i1 = (# ar)-1, j1 = (# ar)-1, temp = ar[i -1], # ar ≠ 0, ar ≠ [], i ≠ 0, i -1 < # ar, j < # ar, i < # ar, ordered≤(rev(subarray(ar, i, # ar - i))), i ≤ j, ¬ ar[j] ≤ ar[i -1], i ≠ 0 → (i -1 < # ar ∧ i ≠ 0) ∧ i < # ar, ∀ n. n > j ∧ n < # ar → ar[n] ≤ ar[i - 1] ⊦ ⟨ar[i -1] := ar[j]; ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar[i -1] ≥ ar[i]

Rule argument

Additional information

Proof step 37 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 38:

  ar = ar1[i -1, ar1[j]], ar1 = ar0, ghostar = ar1, i1 = (# ar1)-1, j1 = (# ar1)-1, temp = ar1[i -1], # ar1 ≠ 0, ar1 ≠ [], i ≠ 0, i < # ar1, i -1 < # ar1, j < # ar1, ordered≤(rev(subarray(ar1, i, # ar1 - i))), i ≤ j, ¬ ar1[j] ≤ ar1[i -1], i ≠ 0 → (i -1 < # ar1 ∧ i ≠ 0) ∧ i < # ar1, ∀ n. n > j ∧ n < # ar1 → ar1[n] ≤ ar1[i - 1] ⊦ ⟨ar[j] := temp; /* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar1[i -1] ≥ ar1[i]

Rule argument

Additional information

Proof step 38 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 39:

  ar = ar2[j, temp], ar1 = ar0, ar2 = ar1[i -1, ar1[j]], ghostar = ar1, i1 = (# ar1)-1, j1 = (# ar1)-1, temp = ar1[i -1], # ar1 ≠ 0, ar1 ≠ [], i ≠ 0, j < # ar1, i -1 < # ar1, i < # ar1, j < # ar2, ordered≤(rev(subarray(ar1, i, # ar1 - i))), i ≤ j, ¬ ar1[j] ≤ ar1[i -1], i ≠ 0 → (i -1 < # ar1 ∧ i ≠ 0) ∧ i < # ar1, ∀ n. n > j ∧ n < # ar1 → ar1[n] ≤ ar1[i - 1] ⊦ ⟨/* next-proper-permutation: ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1] */; let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar1[i -1] ≥ ar1[i]

Rule argument

Additional information

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

Proof step 39 from proof next-proper-permutation (previous step) (back to tree)

Heuristic annotation applied rule annotation right

And obtained the following new goals

• Proof step 40:

  ar = ar2[j, temp], ar1 = ar0, ar2 = ar1[i -1, ar1[j]], ghostar = ar1, i1 = (# ar1)-1, j1 = (# ar1)-1, temp = ar1[i -1], # ar1 ≠ 0, ar1 ≠ [], i ≠ 0, j < # ar2, i < # ar1, i -1 < # ar1, j < # ar1, ordered≤(rev(subarray(ar1, i, # ar1 - i))), i ≤ j, ¬ ar1[j] ≤ ar1[i -1], i ≠ 0 → (i -1 < # ar1 ∧ i ≠ 0) ∧ i < # ar1, ∀ n. n > j ∧ n < # ar1 → ar1[n] ≤ ar1[i - 1] ⊦ i ≠ 0 ∧ ar1[i -1] ≥ ar1[i], ordered≤(rev(subarray(ar, i, # ar - i))) ∧ (∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1]) ∧ ghostar ≠ ar ∧ ghostar ≤ ar ∧ ghostar[j] = ar[i - 1]

• Proof step 58:

  ghostar[j] = ar[i - 1], ar = ar2[j, temp], ar1 = ar0, ar2 = ar1[i -1, ar1[j]], ghostar = ar1, i1 = (# ar1)-1, j1 = (# ar1)-1, temp = ar1[i -1], # ar1 ≠ 0, ar1 ≠ [], ghostar ≠ ar, i ≠ 0, j < # ar2, i < # ar1, i -1 < # ar1, j < # ar1, ordered≤(rev(subarray(ar, i, # ar - i))), ordered≤(rev(subarray(ar1, i, # ar1 - i))), ghostar ≤ ar, i ≤ j, ¬ ar1[j] ≤ ar1[i -1], i ≠ 0 → (i -1 < # ar1 ∧ i ≠ 0) ∧ i < # ar1, ∀ n. n ≥ j ∧ n < # ar → ar[n] < ar[i - 1], ∀ n. n > j ∧ n < # ar1 → ar1[n] ≤ ar1[i - 1] ⊦ ⟨let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ghostar, ar) ∧ subarray(ghostar, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ghostar[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0)), i ≠ 0 ∧ ar1[i -1] ≥ ar1[i]

Rule argument

Additional information

Proof step 40 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 41:

  ar1 ≠ [], i ≠ 0, ar1[i - 1] < ar1[i], ar1[i - 1] < ar1[j], i < # ar1, j < # ar1, ordered≤(rev(subarray(ar1, i, # ar1 - i))), i ≤ j, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[i - 1] ⊦ ordered≤(rev(subarray(ar1[i - 1, ar1[j]][j, ar1[i - 1]], i, # ar1 - i))) ∧ (j ≤ n ∧ n < # ar1 → ar1[i - 1, ar1[j]][j, ar1[i - 1]][n] < ar1[i - 1, ar1[j]][j, ar1[i - 1]][i - 1]) ∧ ar1 ≠ ar1[i - 1, ar1[j]][j, ar1[i - 1]] ∧ ar1 ≤ ar1[i - 1, ar1[j]][j, ar1[i - 1]] ∧ ar1[j] = ar1[i - 1, ar1[j]][j, ar1[i - 1]][i - 1]

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 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 ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n ≥ m ↔ m ≤ n; (s) ⊦ n -1 = n - 1; (s) ⊦ # ar[n, a] = # ar; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ a < b → (b < a ↔ false); (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m > n ↔ n < m; (s)

Proof step 41 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 42:

  i = m + 1, ar1 ≠ [], i ≠ 0, j < # ar1, i < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[i], ordered≤(rev(subarray(ar1, i, # ar1 - i))), i ≤ j, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], i, # ar1 - i))) ∧ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[m, ar1[j]][j, ar1[m]][m]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[m]] ∧ ar1 ≤ ar1[m, ar1[j]][j, ar1[m]] ∧ ar1[j] = ar1[m, ar1[j]][j, ar1[m]][m]

Rule argument

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: i, m

Proof step 42 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 43:

  ar1 ≠ [], m < j, j < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m < # ar1, m + 1 < # ar1, ordered≤(rev(subarray(ar1, m + 1, # ar1 - m + 1))), ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, # ar1 - m + 1))) ∧ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[m]]

Rule argument

Additional information

Used simplifier rules: array-le-swap: ⊦ i < # ar ∧ j < # ar ∧ i < j → (ar ≤ ar[i, ar[j]][j, ar[i]] ↔ ar[i] ≤ ar[j]); ⊦ m < n → m ≤ n; (s) ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] m < # ar ⊦ ar[m, a][m] = a; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ m + n < m; (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ n < m → ar[m, a][n] = ar[n]; (s) ⊦ ar[n] = a → ar[n, a] = ar; (s) ⊦ m + m0 < n → ar[m, a][n] = ar[n]; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 43 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 44:

  # ar1 = n0 + m + 1, ar1 ≠ [], m + 1 < # ar1, m < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], j < # ar1, m < j, ordered≤(rev(subarray(ar1, m + 1, n0))), m + 1 ≤ # ar1, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))) ∧ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[m]]

Rule argument

Additional information

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

Proof step 44 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 45:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < j, j < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m + 1 < # ar1, m < # ar1, ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))) ∧ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 45 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 46:

  ⊦ # ar1 = n0 + m + 1 ∧ n0 ≠ 0 ∧ ar1[m] < ar1[j] ∧ j < # ar1 ∧ m < j ∧ ordered≤(rev(subarray(ar1, m + 1, n0))) ∧ (∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m]) → ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0)))

• Proof step 47:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < # ar1, m + 1 < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], j < # ar1, m < j, ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, # ar1 = n0 + m + 1 ∧ n0 ≠ 0 ∧ ar1[m] < ar1[j] ∧ j < # ar1 ∧ m < j ∧ ordered≤(rev(subarray(ar1, m + 1, n0))) ∧ (∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m]) → ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))) ∧ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[m]]

Rule argument

Additional information

Used terms: ar1, n0, m, j

Proof step 46 from proof next-proper-permutation (previous step) (back to tree)

Lemma remains-ordered-by-swap

Proof step 47 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 48:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < j, j < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m + 1 < # ar1, m < # ar1, ordered≤(rev(subarray(ar1, m + 1, n0))), ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦ (j ≤ n ∧ n < # ar1 → ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j]) ∧ ar1 ≠ ar1[m, ar1[j]][j, ar1[m]]

Rule argument

Additional information

Proof step 48 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 49:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, n < # ar1, m < # ar1, m + 1 < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], j < # ar1, m < j, ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n, j ≤ n0 + m, ¬ ar1[m, ar1[j]][j, ar1[m]][n] < ar1[j], ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

• Proof step 53:

  # ar1 = n0 + m + 1, ar1 = ar1[m, ar1[j]][j, ar1[m]], ar1 ≠ [], n0 ≠ 0, m < # ar1, m + 1 < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], j < # ar1, m < j, ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

Rule argument

Additional information

Proof step 49 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 50:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < j, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m + 1 < # ar1, m < # ar1, n < # ar1, j < # ar1, m < n, ar1[m] < ar1[m, ar1[j]][j, ar1[m]][n], ordered≤(rev(subarray(ar1, m + 1, n0))), ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), j ≤ n0 + m, n ≤ n0 + m, j ≤ n, ar1[j] ≤ ar1[m, ar1[j]][j, ar1[m]][n], ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ 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) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic

Proof step 50 from proof next-proper-permutation (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 51:

  # ar1 = n0 + m + 1, ar1 ≠ [], n ≠ j, n0 ≠ 0, ar1[m] < ar1[m, ar1[j]][j, ar1[m]][n], m < n, j < # ar1, n < # ar1, m < # ar1, m + 1 < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], m < j, ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), ordered≤(rev(subarray(ar1, m + 1, n0))), ar1[j] ≤ ar1[m, ar1[j]][j, ar1[m]][n], j ≤ n, n ≤ n0 + m, j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ m; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) m < # ar ⊦ ar[m, a][m] = a; (s) ⊦ m < n → (n ≤ m ↔ false); (s) Used formulas: n = j

Proof step 51 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 52:

  # ar1 = n0 + m + 1, ar1 ≠ [], n ≠ j, n0 ≠ 1, n0 ≠ 0, 2 + m < # ar1, m + 1 < # ar1, j < n0 + m, m < n, j < # ar1, n < # ar1, m < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], m < j, j < n, ar1[m] < ar1[n], m + 1 < n, ordered≤(rev(subarray(ar1[m, ar1[j]][j, ar1[m]], m + 1, n0))), ordered≤(rev(subarray(ar1, m + 1, n0))), ar1[j] ≤ ar1[n], n ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[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 ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) n0 < n ⊦ (* n) < m0 + (* n0) ↔ n - n0 < m0; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] ⊦ m < n → m ≤ n; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m < n → ar[m, a][n] = ar[n]; (s) ⊦ m ≠ n → (m ≤ n ↔ m < n); (s)

Proof step 52 from proof next-proper-permutation (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: n

Proof step 53 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 54:

  # ar1 = n0 + m + 1, ar1 = ar1[m, ar1[j]][j, ar1[m]], ar1 ≠ [], n0 ≠ 0, m < j, j < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m + 1 < # ar1, m < # ar1, ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

Rule argument

Additional information

Proof step 54 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 55:

  ⊦ ar1 = ar2 ↔ # ar1 = # ar2 ∧ (∀ n. n < # ar1 → ar1[n] = ar2[n])

• Proof step 56:

  # ar1 = # ar1[m, ar1[j]][j, ar1[m]], # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < # ar1, m + 1 < # ar1, ar1[m] < ar1[m + 1], ar1[m] < ar1[j], j < # ar1, m < j, ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m], ∀ n. n < # ar1 → ar1[n] = ar1[m, ar1[j]][j, ar1[m]][n] ⊦

Rule argument

Additional information

Used terms: ar1, ar1[m, ar1[j]][j, ar1[m]]

Proof step 55 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 56 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 57:

  # ar1 = n0 + m + 1, ar1 ≠ [], n0 ≠ 0, m < j, j < # ar1, ar1[m] < ar1[j], ar1[m] < ar1[m + 1], m + 1 < # ar1, m < # ar1, ordered≤(rev(subarray(ar1, m + 1, n0))), j ≤ n0 + m, ∀ n. n < # ar1 → ar1[n] = ar1[m, ar1[j]][j, ar1[m]][n], ∀ n. j < n ∧ n < # ar1 → ar1[n] ≤ ar1[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ n < # x → # x[n, a] = # x; (s) ⊦ # ar[n, a] = # ar; (s)

Proof step 57 from proof next-proper-permutation (previous step) (back to tree)

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ n < m → ar[m, a][n] = ar[n]; (s) ⊦ m < # ar → ar[m, a][m] = a; (s) ⊦ ar[n] = a → ar[n, a] = ar; (s) transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m < n → ¬ n < m; (s) Used terms: m

Proof step 58 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 59:

  ar0[j] = ar0[i - 1, ar0[j]][j, ar0[i - 1]][i - 1], ar = ar0[i - 1, ar0[j]][j, ar0[i - 1]], ar1 = ar0, ar0 ≠ ar0[i - 1, ar0[j]][j, ar0[i - 1]], ar0 ≠ [], i ≠ 0, ar0[i - 1] < ar0[i], ar0[i - 1] < ar0[j], i < # ar0, j < # ar0, ordered≤(rev(subarray(ar0[i - 1, ar0[j]][j, ar0[i - 1]], i, # ar0 - i))), ordered≤(rev(subarray(ar0, i, # ar0 - i))), ar0 ≤ ar0[i - 1, ar0[j]][j, ar0[i - 1]], i ≤ j, ∀ n. j ≤ n ∧ n < # ar0 → ar0[i - 1, ar0[j]][j, ar0[i - 1]][n] < ar0[j], ∀ n. j < n ∧ n < # ar0 → ar0[n] ≤ ar0[i - 1] ⊦ ⟨let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 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 lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n ≥ m ↔ m ≤ n; (s) ⊦ n -1 = n - 1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ a < b → (b < a ↔ false); (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ m > n ↔ n < m; (s)

Proof step 59 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 60:

  ar0[j] = ar0[m, ar0[j]][j, ar0[m]][m], ar = ar0[m, ar0[j]][j, ar0[m]], ar1 = ar0, i = m + 1, ar0 ≠ ar0[m, ar0[j]][j, ar0[m]], ar0 ≠ [], i ≠ 0, j < # ar0, i < # ar0, ar0[m] < ar0[j], ar0[m] < ar0[i], ordered≤(rev(subarray(ar0, i, # ar0 - i))), ordered≤(rev(subarray(ar0[m, ar0[j]][j, ar0[m]], i, # ar0 - i))), i ≤ j, ar0 ≤ ar0[m, ar0[j]][j, ar0[m]], ∀ n. j < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j ≤ n ∧ n < # ar0 → ar0[m, ar0[j]][j, ar0[m]][n] < ar0[j] ⊦ ⟨let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: i, m

Proof step 60 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 61:

  ar = ar0[m, ar0[j]][j, ar0[m]], ar1 = ar0, i = m + 1, ar0 ≠ ar0[m, ar0[j]][j, ar0[m]], ar0 ≠ [], ar0[m] < ar0[m + 1], ar0[m] < ar0[j], m + 1 < # ar0, j < # ar0, m < j, m < # ar0, ordered≤(rev(subarray(ar0[m, ar0[j]][j, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ∀ n. j ≤ n ∧ n < # ar0 → ar0[m, ar0[j]][j, ar0[m]][n] < ar0[j], ∀ n. j < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ ⟨let ghost_j = j in {j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used simplifier rules: array-le-swap: ⊦ i < # ar ∧ j < # ar ∧ i < j → (ar ≤ ar[i, ar[j]][j, ar[i]] ↔ ar[i] ≤ ar[j]); c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m < n → m ≤ n; (s) ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] m < # ar ⊦ ar[m, a][m] = a; (s) ⊦ m ≤ n → (n < m ↔ false); (s) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ n < m → ar[m, a][n] = ar[n]; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 61 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule let right

And obtained the following new goals

• Proof step 62:

  ar = ar0[m, ar0[j]][j, ar0[m]], ar1 = ar0, ghost_j = j, i = m + 1, ar0 ≠ ar0[m, ar0[j]][j, ar0[m]], ar0 ≠ [], m < # ar0, m < j, j < # ar0, m + 1 < # ar0, ar0[m] < ar0[j], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j]][j, ar0[m]], m + 1, # ar0 - m + 1))), ∀ n. j < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j ≤ n ∧ n < # ar0 → ar0[m, ar0[j]][j, ar0[m]][n] < ar0[j] ⊦ ⟨j := (# ar)-1; while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Proof step 62 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 63:

  ar = ar0[m, ar0[j0]][j0, ar0[m]], ar1 = ar0, ghost_j = j0, i = m + 1, j = (# ar)-1, # ar ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ ⟨while i < j do {/* next-proper-permutation: invariant j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)) wfbound j */; temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1}; hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used simplifier rules: ⊦ # ar[n, a] = # ar; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ # x = 0 ↔ x = []; (s)

Proof step 63 from proof next-proper-permutation (previous step) (back to tree)

Heuristic annotation applied rule annotation right

And obtained the following new goals

• Proof step 64:

  ar = ar0[m, ar0[j0]][j0, ar0[m]], ar1 = ar0, ghost_j = j0, i = m + 1, j = (# ar)-1, # ar ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i - 1) = subarray(ar, 0, i - 1) ∧ ar1[ghost_j] = ar[i - 1] ∧ (i < j → rev(subarray(ar, i, # ar - i)) = subarray(ar, i, i - i) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar, i, # ar - i)) = subarray(ar, i, # ar - i))

• Proof step 81:

  ar1[ghost_j] = ar[i0 - 1], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1), # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], j < # ar, i < # ar, i < j, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar1, ar), i0 ≤ i, i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1), i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ ⟨temp := ar[i]; ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1⟩ ( ( j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i0 ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j < j1)

• Proof step 111:

  ar1[ghost_j] = ar[i0 - 1], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ghost_j = j0, i0 = m + 1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1), # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], j < # ar, i < # ar, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar1, ar), i0 ≤ i, ¬ i < j, i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1), i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ ⟨hasNext := true⟩ (hasNext ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Used formulas: j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i` ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i` - 1) = subarray(ar, 0, i` - 1) ∧ ar1[ghost_j] = ar[i` - 1] ∧ ( i < j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, i - i`) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar`, i`, # ar - i`)) = subarray(ar, i`, # ar - i`)), j = j

Proof step 64 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 65:

  ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ ( 2 + m < # ar0 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1)) = mkarray(0) + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - 1 - m)) + subarray(ar0, (# ar0 - 1) + 1, # ar0 - (# ar0 - 1) + 1)) ∧ ( # ar0 ≤ 2 + m → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))

Rule argument

Additional information

Used simplifier rules: subarray-write-above: n ≥ n0 + n1 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ n < # x → # x[n, a] = # x; (s) ⊦ # ar[n, a] = # ar; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n0 ≤ n ⊦ n - n0 ≤ m ↔ n ≤ m + n0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n ≥ m ↔ m ≤ n; (s) ⊦ n -1 = n - 1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] n < n0 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m + n - n + n1 = m - n1; (s) ⊦ subarray(ar, n, 0) = mkarray(0); (s) ⊦ ¬ a < a; (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m - m = 0; (s) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ m < # ar → ar[m, a][m] = a; (s) ⊦ n < m → ar[m, a][n] = ar[n]; (s) ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m < n → m ≤ n; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 65 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 66:

  # ar0 = m0 + 1, # ar0 ≠ 0, ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ ( 2 + m < # ar0 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1)) = mkarray(0) + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, m0 - m)) + subarray(ar0, m0 + 1, # ar0 - m0 + 1)) ∧ ( # ar0 ≤ 2 + m → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))

Rule argument

Additional information

Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: # ar0, m0

Proof step 66 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 67:

  # ar0 = m0 + 1, ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], m < j0, m < m0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0, m + 1, m0 - m))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, m0 - m))), j0 ≤ m0, ∀ n. j0 < n ∧ ¬ m0 < n → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ ¬ m0 < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ ( m + 1 < m0 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, m0 - m)) = mkarray(0) + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, m0 - m)) + mkarray(0)) ∧ (m0 = m + 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1))

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 → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + n - n + n1 = m - n1; (s) ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) n < n0 ⊦ m + (* n) ≤ m0 + (* n0) ↔ m ≤ m0 + (n0 - n); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ subarray(ar, n, 0) = mkarray(0); (s) ⊦ m - m = 0; (s) n0 < n ⊦ m + (* n) < m0 + (* n0) ↔ m + (n - n0) < m0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ a < b → (b < a ↔ false); (ss) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m +1 = m + 1; (s) ⊦ m + 1 ≠ 0; (s) lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ # x = 0 ↔ x = []; (s)

Proof step 67 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 68:

  # ar0 = m0 + 1, m0 = n0 + m, ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m < m0, m < j0, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), ordered≤(rev(subarray(ar0, m + 1, n0))), j0 ≤ m0, m ≤ m0, ∀ n. j0 ≤ n ∧ ¬ m0 < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ ¬ m0 < n → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ ( m + 1 < m0 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) = mkarray(0) + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) + mkarray(0)) ∧ (m0 = m + 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1))

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → m ≤ n; (s) n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: m0, m, n0

Proof step 68 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 69:

  # ar0 = (n0 + m) + 1, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], n0 ≠ 0, m < j0, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), ordered≤(rev(subarray(ar0, m + 1, n0))), j0 ≤ n0 + m, ∀ n. j0 ≤ n ∧ ¬ n0 + m < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ ¬ n0 + m < n → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ (n0 ≠ 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) = mkarray(0) + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) + mkarray(0)) ∧ (n0 = 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1))

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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → m ≤ n; (s)

Proof step 69 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 70:

  ⊦ [] = mkarray(0)

• Proof step 71:

  # ar0 = (n0 + m) + 1, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], n0 ≠ 0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], m < j0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), j0 ≤ n0 + m, ∀ n. j0 < n ∧ ¬ n0 + m < n → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ ¬ n0 + m < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ (n0 ≠ 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) = [] + rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0)) + []) ∧ (n0 = 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1))

Rule argument

Additional information

Used terms:

Proof step 70 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 71 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 72:

  # ar0 = (n0 + m) + 1, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], n0 ≠ 0, m < j0, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), ordered≤(rev(subarray(ar0, m + 1, n0))), j0 ≤ n0 + m, ∀ n. j0 ≤ n ∧ ¬ n0 + m < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ ¬ n0 + m < n → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]) ∧ (n0 = 1 → rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) = subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1))

Rule argument

Additional information

Used simplifier rules: ⊦ rev(x) = rev(y) ↔ x = y; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ x + [] = x; (s) ⊦ [] + x = x; (s)

Proof step 72 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 73:

  # ar0 = (n0 + m) + 1, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], n0 ≠ 0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], m < j0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), j0 ≤ n0 + m, ¬ perm(ar0, ar0[m, ar0[j0]][j0, ar0[m]]), ∀ n. j0 < n ∧ ¬ n0 + m < n → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ ¬ n0 + m < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦

• Proof step 75:

  # ar0 = (n0 + m) + 1, n0 = 1, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], n0 ≠ 0, rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1)) ≠ subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, 1), ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], m < j0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, n0))), j0 ≤ n0 + m, ∀ n. j0 < n ∧ ¬ n0 + m < n → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ ¬ n0 + m < n → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦

Rule argument

Additional information

Proof step 73 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 74:

  ⊦ m < # y ∧ n < # y ∧ a = y[n] ∧ b = y[m] → (perm(x, y[m, a][n, b]) ↔ perm(x, y))

Rule argument

Additional information

Used simplifier rules: ⊦ perm(x, x); (s) let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m = n + 1 → ¬ m ≤ n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat 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 < m; (s) Used terms: ar0, j0, m, ar0, ar0[j0], ar0[m]

Proof step 74 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 75 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 76:

  # ar0 = 2 + m, ar0 ≠ [], ar0 ≠ ar0[m, ar0[m + 1]][m + 1, ar0[m]], rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)) ≠ subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1), ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0, m + 1, 1))), ordered≤(rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1))), ∀ n. m < n ∧ ¬ 1 + m < n → ar0[m, ar0[m + 1]][m + 1, ar0[m]][n] < ar0[m + 1] ⊦

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 + 1 ≤ n ↔ m < n; (s) ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s)

Proof step 76 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 77:

  ⊦ ar1 = ar2 ↔ # ar1 = # ar2 ∧ (∀ n. n < # ar1 → ar1[n] = ar2[n])

• Proof step 78:

  # ar0 = 2 + m, ar0 ≠ [], ar0 ≠ ar0[m, ar0[m + 1]][m + 1, ar0[m]], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1))), ordered≤(rev(subarray(ar0, m + 1, 1))), ∀ n. m < n ∧ ¬ 1 + m < n → ar0[m, ar0[m + 1]][m + 1, ar0[m]][n] < ar0[m + 1], # rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)) ≠ # subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1) ∨ (∃ n. ¬ ( n < # rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)) → rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1))[n] = subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)[n])) ⊦

Rule argument

Additional information

Used terms: rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)), subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1)

Proof step 77 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 78 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 79:

  # ar0 = 2 + m, rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1))[0] ≠ ar0[m], ar0 ≠ ar0[m, ar0[m + 1]][m + 1, ar0[m]], ar0 ≠ [], ar0[m] < ar0[m + 1], ordered≤(rev(subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1))), ordered≤(rev(subarray(ar0, m + 1, 1))), ∀ n. m < n ∧ ¬ 1 + m < n → ar0[m, ar0[m + 1]][m + 1, ar0[m]][n] < ar0[m + 1] ⊦

Rule argument

Additional information

Used simplifier rules: m < # ar ⊦ ar[m, a][m] = a; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # subarray(ar, m, n) = n; (s) ⊦ # rev(x) = # x; (s)

Proof step 79 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 80:

  ⊦ n < # ar → rev(ar)[n] = ar[# ar - n + 1]

Rule argument

Additional information

Used simplifier rules: ⊦ # subarray(ar, m, n) = n; (s) ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic m < # ar ⊦ ar[m, a][m] = a; (s) Used terms: subarray(ar0[m, ar0[m + 1]][m + 1, ar0[m]], m + 1, 1), 0

Proof step 80 from proof next-proper-permutation (previous step) (back to tree)

Lemma get-rev

Proof step 81 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 82:

  ar1[ghost_j] = ar[i0 - 1], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1), temp = ar[i], # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, i < j, j < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, i < # ar, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar1, ar), i0 ≤ i, i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0), i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ ⟨ar[i] := ar[j]; ar[j] := temp; i := i + 1; j := j -1⟩ ( ( j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i0 ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j < j1)

Rule argument

Additional information

Proof step 82 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 83:

  ar1[ghost_j] = ar3[i0 - 1], ar = ar3[i, ar3[j]], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar3, 0, i0 - 1), temp = ar3[i], # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], i < j, i < # ar3, j < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar1, ar3), i0 ≤ i, i < j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, i - i0) + rev(subarray(ar3, i, j + 1 - i)) + subarray(ar3, j + 1, # ar3 - j + 1), i ≥ j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, # ar3 - i0), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ ⟨ar[j] := temp; i := i + 1; j := j -1⟩ ( ( j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i0 ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j < j1)

Rule argument

Additional information

Proof step 83 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 84:

  ar1[ghost_j] = ar3[i0 - 1], ar = ar4[j, temp], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ar4 = ar3[i, ar3[j]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar3, 0, i0 - 1), temp = ar3[i], # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, j < # ar3, i < # ar3, i < j, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, j < # ar4, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar1, ar3), i0 ≤ i, i ≥ j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, # ar3 - i0), i < j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, i - i0) + rev(subarray(ar3, i, j + 1 - i)) + subarray(ar3, j + 1, # ar3 - j + 1), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ ⟨i := i + 1; j := j -1⟩ ( ( j < # ar ∧ i < # ar ∧ i ≠ 0 ∧ i0 ≤ i ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j < j1)

Rule argument

Additional information

Used simplifier rules: ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ n + 0 = n; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 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 ≠ 0; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s)

Proof step 84 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 85:

  ar1[ghost_j] = ar3[i0 - 1], ar = ar4[j, temp], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ar4 = ar3[i, ar3[j]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar3, 0, i0 - 1), temp = ar3[i], # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, j < # ar4, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], i < j, i < # ar3, j < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar1, ar3), i0 ≤ i, i < j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, i - i0) + rev(subarray(ar3, i, j + 1 - i)) + subarray(ar3, j + 1, # ar3 - j + 1), i ≥ j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, # ar3 - i0), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0] ⊦ ⟨j := j -1⟩ ( ( j < # ar ∧ i + 1 < # ar ∧ i + 1 ≠ 0 ∧ i0 ≤ i + 1 ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i + 1 < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i + 1 - i0) + rev(subarray(ar, i + 1, j + 1 - i + 1)) + subarray(ar, j + 1, # ar - j + 1)) ∧ (i + 1 ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j < j1)

Rule argument

Additional information

Proof step 85 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 86:

  ar1[ghost_j] = ar3[i0 - 1], ar = ar4[j, temp], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ar4 = ar3[i, ar3[j]], ghost_j = j0, i0 = m + 1, j = j1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar3, 0, i0 - 1), temp = ar3[i], # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, j ≠ 0, j < # ar3, i < # ar3, i < j, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, j < # ar4, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar1, ar3), i0 ≤ i, i ≥ j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, # ar3 - i0), i < j → rev(subarray(ar2, i0, # ar3 - i0)) = subarray(ar3, i0, i - i0) + rev(subarray(ar3, i, j + 1 - i)) + subarray(ar3, j + 1, # ar3 - j + 1), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ ( j -1 < # ar ∧ i + 1 < # ar ∧ i + 1 ≠ 0 ∧ i0 ≤ i + 1 ∧ perm(ar1, ar) ∧ subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1) ∧ ar1[ghost_j] = ar[i0 - 1] ∧ ( i + 1 < j -1 → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i + 1 - i0) + rev(subarray(ar, i + 1, j -1 + 1 - i + 1)) + subarray(ar, j -1 + 1, # ar - j -1 + 1)) ∧ (i + 1 ≥ j -1 → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0))) ∧ j -1 < j1

Rule argument

Additional information

Used simplifier rules: ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ n + 0 = n; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ 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 ≠ 0; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ x ≠ [] → x[0] = x.first; (s) ⊦ ¬ n < 0; (s)

Proof step 86 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 87:

  ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, i - m + 1) + rev(subarray(ar3, i, j1 + 1 - i)) + subarray(ar3, j1 + 1, # ar3 - j1 + 1), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], i + 1 < # ar3, m + 1 < j1, m < j1, m < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], i < j1, i < # ar3, m < i, j1 < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[i, ar3[j1]][j1, ar3[i]]) ∧ ( 2 + i < j1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[j1]], m + 1, i - m) + rev(subarray(ar3[i, ar3[j1]][j1, ar3[i]], i + 1, j1 - 1 - i)) + subarray(ar3[i, ar3[j1]][j1, ar3[i]], (j1 - 1) + 1, # ar3 - (j1 - 1) + 1)) ∧ ( j1 ≤ 2 + i → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[j1]][j1, ar3[i]], m + 1, # ar3 - m + 1))

Rule argument

Additional information

Used simplifier rules: subarray-write-above: n ≥ n0 + n1 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m +1 = m + 1; (s) lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] ⊦ n < m → ar[m, a][n] = ar[n]; (s) ⊦ n + n0 < m → ar[m, a][n] = ar[n]; (s) ⊦ m < n → n ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ n -1 = n - 1; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ # ar[n, a] = # ar; (s) n0 ≤ n ⊦ n - n0 ≤ m ↔ n ≤ m + n0; (s) ⊦ n ≥ m ↔ m ≤ n; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ m + n - n + n1 = m - n1; (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ n < m → (m - n) + n = m; (s) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m < n → m ≤ n; (s) ⊦ m < n → ¬ n < m; (s) ⊦ m < n → ar[m, a][n] = ar[n]; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 87 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 88:

  ar0[j0] = ar3[m], j1 = m0 + 1, rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, i - m + 1) + rev(subarray(ar3, i, j1 + 1 - i)) + subarray(ar3, j1 + 1, # ar3 - j1 + 1), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], j1 ≠ 0, 2 + m < # ar3, m + 1 < # ar3, ar0[m] < ar3[m], j1 < # ar3, m < i, i < # ar3, i < j1, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, m < # ar3, m < j1, m + 1 < j1, i + 1 < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar3), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[i, ar3[j1]][j1, ar3[i]]) ∧ ( 2 + i < j1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[j1]], m + 1, i - m) + rev(subarray(ar3[i, ar3[j1]][j1, ar3[i]], i + 1, m0 - i)) + subarray(ar3[i, ar3[j1]][j1, ar3[i]], m0 + 1, # ar3 - m0 + 1)) ∧ ( j1 ≤ 2 + i → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[j1]][j1, ar3[i]], m + 1, # ar3 - m + 1))

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] n0 < n ⊦ ¬ m + (* n) < (* n0); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: j1, m0

Proof step 88 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 89:

  ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, i - m + 1) + rev(subarray(ar3, i, (m0 - i) + 2)) + subarray(ar3, 2 + m0, # ar3 - 2 + m0), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], m < m0, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, m < # ar3, i + 1 < # ar3, 2 + m < # ar3, m + 1 < # ar3, ar0[m] < ar3[m], m0 + 1 < # ar3, m < i, i < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar3), i ≤ m0, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]]) ∧ ( i + 1 < m0 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[m0 + 1]], m + 1, i - m) + rev(subarray(ar3, i + 1, m0 - i)) + subarray(ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]], m0 + 1, # ar3 - m0 + 1)) ∧ ( m0 ≤ i + 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]], m + 1, # ar3 - m + 1))

Rule argument

Additional information

Used simplifier rules: subarray-write-above: n ≥ n0 + n1 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); ⊦ m < n → n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat 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 n < n0 ⊦ m + (* n) ≤ m0 + (* n0) ↔ m ≤ m0 + (n0 - n); (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] n < n0 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); (s) ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) ⊦ n ≥ m ↔ m ≤ n; (s) ⊦ n ≤ n0 → (m + (n0 - n)) + n = m + n0; (s) n0 < n ⊦ m + (* n) < m0 + (* n0) ↔ m + (n - n0) < m0; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ a < b → (b < a ↔ false); (ss) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 89 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 90:

  ar0[j0] = ar3[m], i = n0 + m + 1, rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, i, (m0 - i) + 2)) + subarray(ar3, 2 + m0, # ar3 - 2 + m0), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], i < # ar3, m < i, m0 + 1 < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, 2 + m < # ar3, i + 1 < # ar3, m < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], m < m0, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), i ≤ m0, m + 1 ≤ i, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]]) ∧ ( i + 1 < m0 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[m0 + 1]], m + 1, i - m) + rev(subarray(ar3, i + 1, m0 - i)) + subarray(ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]], m0 + 1, # ar3 - m0 + 1)) ∧ ( m0 ≤ i + 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[i, ar3[m0 + 1]][m0 + 1, ar3[i]], m + 1, # ar3 - m + 1))

Rule argument

Additional information

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

Proof step 90 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 91:

  ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, (m0 - n0 + m + 1) + 2)) + subarray(ar3, 2 + m0, # ar3 - 2 + m0), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], 2 + m < # ar3, m + 1 < # ar3, ar0[m] < ar3[m], m0 + 1 < # ar3, n0 + m + 1 < # ar3, n0 + m < m0, m < m0, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, m < # ar3, 2 + n0 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar3), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]]) ∧ ( 2 + n0 + m < m0 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[m0 + 1]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, m0 - n0 + m + 1)) + subarray(ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]], m0 + 1, # ar3 - m0 + 1)) ∧ ( m0 ≤ 2 + n0 + m → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]], m + 1, # ar3 - m + 1))

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 a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ m + n - m = n; (s) ⊦ ¬ m + n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m ≤ m + n; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s)

Proof step 91 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 92:

  ar0[j0] = ar3[m], m0 = n1 + n0 + m + 1, rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 2 + m0, # ar3 - 2 + m0), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], 2 + n0 + m < # ar3, m < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], m < m0, n0 + m < m0, n0 + m + 1 < # ar3, m0 + 1 < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), n0 + m + 1 ≤ m0, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]]) ∧ ( 2 + n0 + m < m0 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[m0 + 1]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]], m0 + 1, # ar3 - m0 + 1)) ∧ ( m0 ≤ 2 + n0 + m → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[m0 + 1]][m0 + 1, ar3[n0 + m + 1]], m + 1, # ar3 - m + 1))

Rule argument

Additional information

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

Proof step 92 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 93:

  ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, # ar3 - 3 + n1 + n0 + m), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar3), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar3 - m + 1)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, # ar3 - m + 1))

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 n < n0 ⊦ m + (* n) ≤ (* n0) ↔ m ≤ n0 - n; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) n0 < n ⊦ (* n) < m0 + (* n0) ↔ n - n0 < m0; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≤ m + n; (s)

Proof step 93 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 94:

  # ar3 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, # ar3 - 3 + n1 + n0 + m), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), m + 1 ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n2))

Rule argument

Additional information

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

Proof step 94 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 95:

  # ar3 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, # ar3 - 3 + n1 + n0 + m), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 1, n0 + 1 < n2, (n1 + n0) + 1 < n2, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, 2 + n0 + m < # ar3, 2 + m < # ar3, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar3), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n2))

Rule argument

Additional information

Used simplifier rules: ⊦ m < n → n ≠ 0; (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 < m0 → m + n < m0 + n0; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) n0 < n ⊦ m + (* n) < m0 + (* n0) ↔ m + (n - n0) < m0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) n0 < n ⊦ (* n) < m0 + (* n0) ↔ n - n0 < m0; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ ¬ m + n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 95 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 96:

  # ar3 = n2 + m + 1, # ar3 = n3 + 3 + n1 + n0 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 1, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, (n1 + n0) + 1 < n2, n0 + 1 < n2, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n2))

Rule argument

Additional information

Used simplifier rules: ⊦ m ≤ n ↔ ¬ n < m; (ss) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic n < n0 ⊦ m + (* n) < m0 + (* n0) ↔ m < m0 + (n0 - n); (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ m +1 = m + 1; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ a < a; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # ar3, 3 + n1 + n0 + m, n3

Proof step 96 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 97:

  # ar3 = 3 + n0 + n1 + n3 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (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 n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) n < n0 ⊦ (* n) < m0 + (* n0); (s) ⊦ m < m + n ↔ n ≠ 0; (s) n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s) eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic

Proof step 97 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 98:

  # ar3 = 3 + n0 + n1 + n3 + m, # ar0 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, m + 1 ≤ # ar0, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

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

Proof step 98 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 99:

  # ar0 = n2 + m + 1, # ar3 = 3 + n0 + n1 + n3 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], n2 ≠ 0, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, m < # ar0, ordered≤(rev(subarray(ar0, m + 1, n2))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), perm(ar0, ar3), j0 ≤ n2 + m, 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, # ar3 - 2 + n1 + n0 + m)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 99 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 100:

  # ar3 = 3 + n0 + n1 + n3 + m, # ar0 = n2 + m + 1, # ar3 = n4 + 2 + n1 + n0 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar0 ≠ [], ar3 ≠ [], n2 ≠ 0, m < # ar0, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, j0 ≤ n2 + m, 2 + n1 + n0 + m ≤ # ar3, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, n4)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

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 ⊦ m < n → m ≤ n; (s) n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # ar3, 2 + n1 + n0 + m, n4

Proof step 100 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 101:

  # ar3 = 3 + n3 + n1 + n0 + m, # ar0 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, m < # ar0, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, j0 ≤ n2 + m, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], 2 + n1 + n0 + m, n3 + 1)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

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 + 1 ≠ 0; (s) ⊦ m < m + n ↔ n ≠ 0; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) n < n0 ⊦ m + (* n) = m0 + (* n0) ↔ m = m0 + (n0 - n); (s) ⊦ m + n = m + n0 ↔ n = n0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic ⊦ m < n → m ≤ n; (s)

Proof step 101 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 102:

  m ≠ n ⊦ ar[m, a][n, b] = ar[n, b][m, a]

• Proof step 103:

  # ar0 = n2 + m + 1, # ar3 = 3 + n3 + n1 + n0 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), n0 + m + 1 ≠ 2 + n1 + n0 + m, ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, m < # ar0, ordered≤(rev(subarray(ar0, m + 1, n2))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), perm(ar0, ar3), j0 ≤ n2 + m, 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[2 + n1 + n0 + m, ar3[n0 + m + 1]][n0 + m + 1, ar3[2 + n1 + n0 + m]]) ∧ ( n1 ≠ 0 ∧ n1 ≠ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + 1) + rev(subarray(ar3, 2 + n0 + m, n1)) + subarray(ar3[2 + n1 + n0 + m, ar3[n0 + m + 1]][n0 + m + 1, ar3[2 + n1 + n0 + m]], 2 + n1 + n0 + m, n3 + 1)) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[2 + n1 + n0 + m, ar3[n0 + m + 1]][n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

Used simplifier rules: ⊦ m + n = m + n0 ↔ n = n0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: 2 + n1 + n0 + m, ar3, n0 + m + 1, ar3[2 + n1 + n0 + m], ar3[n0 + m + 1]

Proof step 102 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 103 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 104:

  # ar3 = 3 + n3 + n1 + n0 + m, # ar0 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, m < # ar0, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, j0 ≤ n2 + m, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[2 + n1 + n0 + m, ar3[n0 + m + 1]][n0 + m + 1, ar3[2 + n1 + n0 + m]]) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[2 + n1 + n0 + m, ar3[n0 + m + 1]][n0 + m + 1, ar3[2 + n1 + n0 + m]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

Used simplifier rules: rev-subarray-split-step: 3 + n0 + k + n + m ≤ # ar ⊦ subarray(ar[m + n + 1, ar[m + n + 2 + k]], m + 1, n + 1) + rev(subarray(ar, m + n + 2, k)) + subarray(ar[m + n + 2 + k, ar[m + n + 1]], n + m + 2 + k, n0 + 1) = subarray(ar, m + 1, n) + rev(subarray(ar, m + n + 1, k + 2)) + subarray(ar, n + m + 3 + k, n0); a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ a < a; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) n < n0 ⊦ subarray(ar[n, a], n0, n1) = subarray(ar, n0, n1); (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) ⊦ m + n = m + n0 ↔ n = n0; (s)

Proof step 104 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 105:

  m ≠ n ⊦ ar[m, a][n, b] = ar[n, b][m, a]

• Proof step 106:

  # ar0 = n2 + m + 1, # ar3 = 3 + n3 + n1 + n0 + m, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), 2 + n1 + n0 + m ≠ n0 + m + 1, ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, m < # ar0, ordered≤(rev(subarray(ar0, m + 1, n2))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), perm(ar0, ar3), j0 ≤ n2 + m, 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

Used simplifier rules: ⊦ m + n = m + n0 ↔ n = n0; (s) n < n0 ⊦ (* n) ≠ m0 + (* n0); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n0 + m + 1, ar3, 2 + n1 + n0 + m, ar3[n0 + m + 1], ar3[2 + n1 + n0 + m]

Proof step 105 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 106 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 107:

  # ar3 = 3 + n3 + n1 + n0 + m, # ar0 = n2 + m + 1, ar0[j0] = ar3[m], rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3), subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, m < # ar0, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, j0 ≤ n2 + m, ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≤ 1 → rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n0 + n1 + n3 + 2)) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

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 ↔ m = 0 ∧ n = 1 ∨ n = 0 ∧ m = 1; (ws) ⊦ m + n = m + n0 ↔ n = n0; (s)

Proof step 107 from proof next-proper-permutation (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 108:

  # ar0 = n2 + m + 1, # ar3 = 3 + n3 + n1 + n0 + m, ar0[j0] = ar3[m], subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, 2 + m < # ar3, 2 + n0 + m < # ar3, m < # ar3, 2 + n1 + n0 + m < # ar3, ar0[m] < ar3[m], m + 1 < # ar3, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar0[m + 1], n0 + m + 1 < # ar3, m < # ar0, ordered≤(rev(subarray(ar0, m + 1, n2))), ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), perm(ar0, ar3), j0 ≤ n2 + m, 3 + n1 + n0 + m ≤ # ar3, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m] ⊦ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]) ∧ ( n1 ≤ 1 → subarray(ar3, m + 1, n0) + rev(subarray(ar3, n0 + m + 1, n1 + 2)) + subarray(ar3, 3 + n1 + n0 + m, n3) = subarray(ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]], m + 1, n0 + n1 + n3 + 2))

Rule argument

Additional information

Proof step 108 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 109:

  # ar3 = 3 + n3 + n1 + n0 + m, # ar0 = n2 + m + 1, ar0[j0] = ar3[m], subarray(ar0, 0, m) = subarray(ar3, 0, m), ar0 ≠ [], ar0 ≠ ar0[m, ar3[m]][j0, ar0[m]], ar3 ≠ [], n2 ≠ 0, m < # ar0, n0 + m + 1 < # ar3, ar0[m] < ar0[m + 1], m + 1 < # ar0, j0 < # ar0, m < j0, m + 1 < # ar3, ar0[m] < ar3[m], 2 + n1 + n0 + m < # ar3, m < # ar3, 2 + n0 + m < # ar3, 2 + m < # ar3, ordered≤(rev(subarray(ar0[m, ar3[m]][j0, ar0[m]], m + 1, n2))), ordered≤(rev(subarray(ar0, m + 1, n2))), perm(ar0, ar3), 3 + n1 + n0 + m ≤ # ar3, j0 ≤ n2 + m, ¬ perm(ar0, ar3[n0 + m + 1, ar3[2 + n1 + n0 + m]][2 + n1 + n0 + m, ar3[n0 + m + 1]]), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar3[m]][j0, ar0[m]][n] < ar3[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: rev-subarray-split-last-swap: 3 + n0 + k + n + m ≤ # ar ⊦ k ≤ 1 → subarray(ar, m + 1, n) + rev(subarray(ar, m + n + 1, k + 2)) + subarray(ar, m + n + 3 + k, n0) = subarray (ar[m + n + 1, ar[m + n + k + 2]][m + n + k + 2, ar[m + n + 1]], m + 1, n + k + 2 + n0); a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ a < a; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss)

Proof step 109 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 110:

  ⊦ m < # y ∧ n < # y ∧ a = y[n] ∧ b = y[m] → (perm(x, y[m, a][n, b]) ↔ perm(x, y))

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 Used terms: ar3, 2 + n1 + n0 + m, n0 + m + 1, ar0, ar3[2 + n1 + n0 + m], ar3[n0 + m + 1]

Proof step 110 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 111 from proof next-proper-permutation (previous step) (back to tree)

Heuristic symbolic execution applied rule assign right

And obtained the following new goals

• Proof step 112:

  ar1[ghost_j] = ar[i0 - 1], ar1 = ar0, ar2 = ar0[m, ar0[j0]][j0, ar0[m]], ghost_j = j0, i0 = m + 1, j2 = (# ar2)-1, subarray(ar1, 0, i0 - 1) = subarray(ar, 0, i0 - 1), # ar2 ≠ 0, ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar0 ≠ [], i ≠ 0, i < # ar, j < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, ordered≤(rev(subarray(ar0[m, ar0[j0]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar1, ar), i0 ≤ i, ¬ i < j, i ≥ j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, # ar - i0), i < j → rev(subarray(ar2, i0, # ar - i0)) = subarray(ar, i0, i - i0) + rev(subarray(ar, i, j + 1 - i)) + subarray(ar, j + 1, # ar - j + 1), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar0[j0]][j0, ar0[m]][n] < ar0[j0], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦ (true ⊃ nextperm(ar0, ar);ar = ar0 ∧ max(ar0))

Rule argument

Additional information

Proof step 112 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 113:

  ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, # ar - m + 1)) = subarray(ar, m + 1, # ar - m + 1), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, j < # ar, m < # ar, m + 1 < # ar, ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar), j ≤ i, ¬ nextperm(ar0, ar), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ n ≥ m ↔ m ≤ n; (s) ⊦ m ≤ n → (n < m ↔ false); (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 + 1 ≤ n ↔ m < n; (s) ⊦ n < # x → # x[n, a] = # x; (s) ⊦ # ar[n, a] = # ar; (s) ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s)

Proof step 113 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 114:

  # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], m + 1 < # ar, m < # ar, j < # ar, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), perm(ar0, ar), j ≤ i, m + 1 ≤ # ar, ¬ nextperm(ar0, ar), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

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

Proof step 114 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 115:

  # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], n0 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], m + 1 < # ar0, j0 < # ar0, m < j0, m < # ar0, j < # ar, m + 1 < # ar, m < # ar, ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, # ar0 - m + 1))), ordered≤(rev(subarray(ar0, m + 1, # ar0 - m + 1))), perm(ar0, ar), j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ¬ nextperm(ar0, ar), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat let: ⊦ n ≤ n0 ∧ n0 ≤ n1 → n ≤ n1; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ¬ m + n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 115 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

• Proof step 116:

  # ar = n0 + m + 1, # ar0 = n1 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], n0 ≠ 0, m < # ar, m + 1 < # ar, j < # ar, m < # ar0, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n1))), ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n1))), perm(ar0, ar), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, m + 1 ≤ # ar0, ¬ nextperm(ar0, ar), ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

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

Proof step 116 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 117:

  # ar0 = n1 + m + 1, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], n0 ≠ 0, n1 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], m + 1 < # ar0, j0 < # ar0, m < j0, j < # ar, m + 1 < # ar, m < # ar, m < # ar0, ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n1))), ordered≤(rev(subarray(ar0, m + 1, n1))), perm(ar0, ar), j0 ≤ n1 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ¬ nextperm(ar0, ar), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ 1 = m + 1 ↔ m = 0; (s) ⊦ m + 1 ≠ 0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ¬ m + n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 117 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 118:

  ⊦ nextperm(ar1, ar2) ↔ perm(ar1, ar2) ∧ ar1 ≠ ar2 ∧ ar1 ≤ ar2 ∧ (∀ ar3. perm(ar1, ar3) ∧ ar3 ≠ ar1 ∧ ar3 ≠ ar2 → ¬(ar1 ≤ ar3 ∧ ar3 ≤ ar2))

• Proof step 119:

  # ar = n0 + m + 1, # ar0 = n1 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], n0 ≠ 0, n1 ≠ 0, m < # ar0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n1))), ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n1))), perm(ar0, ar), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n1 + m, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ¬ perm(ar0, ar) ∨ ar0 = ar ∨ ¬ ar0 ≤ ar ∨ (∃ ar3. ¬(perm(ar0, ar3) ∧ ar3 ≠ ar0 ∧ ar3 ≠ ar → ¬(ar0 ≤ ar3 ∧ ar3 ≤ ar))) ⊦

Rule argument

Additional information

Used terms: ar0, ar

Proof step 118 from proof next-proper-permutation (previous step) (back to tree)

Lemma next-permutation

Proof step 119 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 120:

  # ar = n0 + m + 1, # ar0 = n1 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, n0 ≠ 0, n1 ≠ 0, m < # ar0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar0, m + 1 < # ar0, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n1))), ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n1))), perm(ar0, ar), perm(ar0, ar3), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n1 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: array-le-one-diffrent-position: ⊦ ar1[m] < ar2[m] ∧ m < # ar2 ∧ m < # ar1 ∧ subarray(ar1, 0, m) = subarray(ar2, 0, m) → ar1 ≤ ar2; array-le-trans: ⊦ ar0 ≤ ar1 ∧ ar1 ≤ ar2 → ar0 ≤ ar2; ⊦ ar[n] = a → ar[n, a] = ar; (s)

Proof step 120 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 121:

  ⊦ perm(x, y) → (# x = # y ↔ true)

• Proof step 122:

  # ar0 = n1 + m + 1, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, n0 ≠ 0, n1 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], m + 1 < # ar0, j0 < # ar0, m < j0, j < # ar, m + 1 < # ar, m < # ar, m < # ar0, ordered≤(rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n1))), ordered≤(rev(subarray(ar0, m + 1, n1))), perm(ar0, ar3), perm(ar0, ar), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n1 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, perm(ar0, ar) → (# ar0 = # ar ↔ true), ∀ n. j0 ≤ n ∧ n < # ar0 → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar0 → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used terms: ar0, ar

Proof step 121 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 122 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 123:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0, ar3), perm(ar0, ar), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[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 → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic

Proof step 123 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 124:

  ⊦ # ar3 = n0 + m + 1 ∧ subarray(ar1, 0, m) = subarray(ar3, 0, m) ∧ m + 1 < # ar3 ∧ n0 ≠ 0 ∧ ar1 ≠ ar3 ∧ perm(ar1, ar2) ∧ perm(ar2, ar3) ∧ ar1 ≤ ar2 ∧ ar2 ≤ ar3 ∧ ar2 ≠ ar1 ∧ ar2 ≠ ar3 → subarray(ar1, m, n0 + 1) ≤ subarray(ar2, m, n0 + 1) ∧ subarray(ar2, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ perm(subarray(ar1, m, n0 + 1), subarray(ar2, m, n0 + 1)) ∧ perm(subarray(ar2, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ subarray(ar1, m, n0 + 1) ≠ subarray(ar2, m, n0 + 1) ∧ subarray(ar2, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1)

• Proof step 125:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar = n0 + m + 1 ∧ subarray(ar0, 0, m) = subarray(ar, 0, m) ∧ m + 1 < # ar ∧ n0 ≠ 0 ∧ ar0 ≠ ar ∧ perm(ar0, ar3) ∧ perm(ar3, ar) ∧ ar0 ≤ ar3 ∧ ar3 ≤ ar ∧ ar3 ≠ ar0 ∧ ar3 ≠ ar → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used terms: n0, ar, m, ar3, ar0

Proof step 124 from proof next-proper-permutation (previous step) (back to tree)

Lemma array-le-kill-prefix

Proof step 125 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 126:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0, ar3), perm(ar0, ar), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, perm(ar3, ar) → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Proof step 126 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 127:

  ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z)

• Proof step 128:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, perm(ar3, ar) → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), perm(ar3, ar0) ∧ perm(ar0, ar) → perm(ar3, ar), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used terms: ar3, ar0, ar

Proof step 127 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 128 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 129:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0, ar3), perm(ar0, ar), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, perm(ar3, ar) → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), perm(ar3, ar0) → perm(ar3, ar), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Proof step 129 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 130:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, ¬ perm(ar3, ar0), perm(ar3, ar) → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

• Proof step 132:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, perm(ar3, ar) → subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1) ∧ perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)) ∧ subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1) ∧ subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Proof step 130 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 131:

  ⊦ perm(x, y) ↔ perm(y, x)

Rule argument

Additional information

Used terms: ar3, ar0

Proof step 131 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 132 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 133:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), subarray(ar0, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1), m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(subarray(ar0, m, n0 + 1), subarray(ar, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)), perm(subarray(ar0, m, n0 + 1), subarray(ar3, m, n0 + 1)), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar0, m, n0 + 1) ≤ subarray(ar, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1), subarray(ar0, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: array-le-kill-prefix: ⊦ # ar3 = n0 + m + 1 ∧ subarray(ar1, 0, m) = subarray(ar3, 0, m) ∧ m + 1 < # ar3 ∧ n0 ≠ 0 ∧ ar1 ≠ ar3 ∧ perm(ar1, ar2) ∧ perm(ar2, ar3) ∧ ar1 ≤ ar2 ∧ ar2 ≤ ar3 ∧ ar2 ≠ ar1 ∧ ar2 ≠ ar3 → subarray(ar1, m, n0 + 1) ≤ subarray(ar2, m, n0 + 1) ∧ subarray(ar2, m, n0 + 1) ≤ subarray(ar3, m, n0 + 1) ∧ perm(subarray(ar1, m, n0 + 1), subarray(ar2, m, n0 + 1)) ∧ perm(subarray(ar2, m, n0 + 1), subarray(ar3, m, n0 + 1)) ∧ subarray(ar1, m, n0 + 1) ≠ subarray(ar2, m, n0 + 1) ∧ subarray(ar2, m, n0 + 1) ≠ subarray(ar3, m, n0 + 1); array-le-trans: ⊦ ar0 ≤ ar1 ∧ ar1 ≤ ar2 → ar0 ≤ ar2; trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic

Proof step 133 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 134:

  m + n ≤ # ar, n ≠ 0 ⊦ subarray(ar, m, n) = ar[m] + subarray(ar, m + 1, n - 1)

• Proof step 135:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), n0 + 1 ≠ 0, ar0[m] + subarray(ar0, m + 1, n0 + 1 - 1) ≠ subarray(ar3, m, n0 + 1), ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] + subarray(ar0, m + 1, n0 + 1 - 1), subarray(ar3, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)), perm(ar0[m] + subarray(ar0, m + 1, n0 + 1 - 1), subarray(ar, m, n0 + 1)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), ar0[m] + subarray(ar0, m + 1, n0 + 1 - 1) ≤ subarray(ar3, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1), ar0[m] + subarray(ar0, m + 1, n0 + 1 - 1) ≤ subarray(ar, m, n0 + 1), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, m + n0 + 1 ≤ # ar0, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ 1 < m ↔ ¬(m = 0 ∨ m = 1); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m = n + 1 → ¬ m ≤ n; (s) Used terms: ar0, m, n0 + 1

Proof step 134 from proof next-proper-permutation (previous step) (back to tree)

Lemma subarray-inc-offset0

Proof step 135 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 136:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar, m, n0 + 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar, m, n0 + 1), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: array-le-trans: ⊦ ar0 ≤ ar1 ∧ ar1 ≤ ar2 → ar0 ≤ ar2; c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ¬ a < a; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m ≤ m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ a + x = a ' + x; (s) ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 136 from proof next-proper-permutation (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 137:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ subarray(ar, m, n0 + 1), m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(subarray(ar3, m, n0 + 1), subarray(ar, m, n0 + 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar, m, n0 + 1)), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar3, m, n0 + 1) ≤ subarray(ar, m, n0 + 1), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar, m, n0 + 1), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used formulas: n0 ≠ 0

Proof step 137 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 138:

  m + n ≤ # ar, n ≠ 0 ⊦ subarray(ar, m, n) = ar[m] + subarray(ar, m + 1, n - 1)

• Proof step 139:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), n0 + 1 ≠ 0, ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ ar[m] + subarray(ar, m + 1, n0 + 1 - 1), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] + subarray(ar, m + 1, n0 + 1 - 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), ar[m] + subarray(ar, m + 1, n0 + 1 - 1)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ ar[m] + subarray(ar, m + 1, n0 + 1 - 1), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ ar[m] + subarray(ar, m + 1, n0 + 1 - 1), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, m + n0 + 1 ≤ # ar, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

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

Proof step 138 from proof next-proper-permutation (previous step) (back to tree)

Lemma subarray-inc-offset0

Proof step 139 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 140:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ ar[m] ' + subarray(ar, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ ar[m] ' + subarray(ar, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: array-le-trans: ⊦ ar0 ≤ ar1 ∧ ar1 ≤ ar2 → ar0 ≤ ar2; lexicographic-rec1: ⊦ n ' + ar1 ≤ m ' + ar2 ↔ (n = m ⊃ ar1 ≤ ar2;n ≤ m); ⊦ ¬ a < a; (s) lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ ar[n, a] = ar ↔ ¬ n < # ar ∨ ar[n] = a; (s) ⊦ ar[n] = a → ar[n, a] = ar; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ m < n → m ≤ n; (s) trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] ⊦ a + x = a ' + x; (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) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 140 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 141:

  m + n ≤ # ar, n ≠ 0 ⊦ subarray(ar, m, n) = ar[m] + subarray(ar, m + 1, n - 1)

• Proof step 142:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ ar[m] ' + subarray(ar, m + 1, n0), m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(subarray(ar3, m, n0 + 1), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar3, m, n0 + 1) ≤ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦ m + n0 + 1 ≤ # ar3 ∧ n0 + 1 ≠ 0

• Proof step 145:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), n0 + 1 ≠ 0, ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1), ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1) ≤ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ ar3[m] + subarray(ar3, m + 1, n0 + 1 - 1), m + n0 + 1 ≤ # ar3, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used terms: ar3, m, n0 + 1

Proof step 141 from proof next-proper-permutation (previous step) (back to tree)

Lemma subarray-inc-offset0

Proof step 142 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 143:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ subarray(ar3, m, n0 + 1), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, subarray(ar3, m, n0 + 1) ≠ ar[m] ' + subarray(ar, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, # ar3 < # ar, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), subarray(ar3, m, n0 + 1)), perm(subarray(ar3, m, n0 + 1), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), ar0[m] ' + subarray(ar0, m + 1, n0) ≤ subarray(ar3, m, n0 + 1), subarray(ar3, m, n0 + 1) ≤ ar[m] ' + subarray(ar, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar3 ≤ m + n0, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[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 → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + 1 ≠ 0; (s) ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 143 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 144:

  ⊦ perm(x, y) → (# x = # y ↔ true)

Rule argument

Additional information

Used simplifier rules: lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (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 fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ m < n → ¬ n < m; (s) Used terms: ar3, ar

Proof step 144 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 145 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 146:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, (ar0[m] = ar3[m] ⊃ subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0);ar0[m] < ar3[m]), (ar3[m] = ar[m] ⊃ subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0);ar3[m] < ar[m]), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: lexicographic-rec1: ⊦ n ' + ar1 ≤ m ' + ar2 ↔ (n = m ⊃ ar1 ≤ ar2;n ≤ m); ⊦ m +1 = m + 1; (s) lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ a + x = a ' + x; (s) ⊦ n + 0 = n; (s) ⊦ n ≤ m → m + n0 - n = (m - n) + n0; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ m ≠ n → (m ≤ n ↔ m < n); (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + 1 ≠ 0; (s)

Proof step 146 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 147:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], ar0[m] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0), (ar3[m] = ar[m] ⊃ subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0);ar3[m] < ar[m]), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

• Proof step 154:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, (ar3[m] = ar[m] ⊃ subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0);ar3[m] < ar[m]), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Proof step 147 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 148:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], ar0[m] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar3[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar3[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar0, m + 1, n0) ≠ subarray(ar3, m + 1, n0), m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar3[m] < ar0[m + 1], ar3[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(ar3[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(subarray(ar0, m + 1, n0), subarray(ar3, m + 1, n0)), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar3[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar3[m] ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ perm(a ' + x, a ' + y) ↔ perm(x, y); (s) trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] ⊦ a ' + x = b ' + y ↔ a = b ∧ x = y; (ws)

Proof step 148 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 149:

  ⊦ ordered≤(rev(ar)) → max(ar)

• Proof step 150:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[m] = ar3[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar3[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar3[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar0, m + 1, n0) ≠ subarray(ar3, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar3[m] < ar[m], ar3[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(subarray(ar0, m + 1, n0), subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))) → max(subarray(ar0, m + 1, n0)), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar3[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar3[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used terms: subarray(ar0, m + 1, n0)

Proof step 149 from proof next-proper-permutation (previous step) (back to tree)

Lemma descending-order-is-max-permuted

Proof step 150 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 151:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], ar0[m] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar3[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar3[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar0, m + 1, n0) ≠ subarray(ar3, m + 1, n0), m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar3[m] < ar0[m + 1], ar3[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, max(subarray(ar0, m + 1, n0)), ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(ar3[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(subarray(ar0, m + 1, n0), subarray(ar3, m + 1, n0)), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar3[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar3[m] ⊦

Rule argument

Additional information

Proof step 151 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 152:

  ⊦ max(ar1) ↔ (∀ ar2. perm(ar1, ar2) → ar2 ≤ ar1)

• Proof step 153:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[m] = ar3[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar3[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar3[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar0, m + 1, n0) ≠ subarray(ar3, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar3[m] < ar[m], ar3[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(subarray(ar0, m + 1, n0), subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), subarray(ar0, m + 1, n0) ≤ subarray(ar3, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar3[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar3[m]][n] < ar[m], ∀ ar2. perm(subarray(ar0, m + 1, n0), ar2) → ar2 ≤ subarray(ar0, m + 1, n0) ⊦

Rule argument

Additional information

Used terms: subarray(ar0, m + 1, n0)

Proof step 152 from proof next-proper-permutation (previous step) (back to tree)

Lemma maximum-permutation

Proof step 153 from proof next-proper-permutation (previous step) (back to tree)

User applied rule all left

And closed the goal!

Rule argument

Additional information

Used simplifier rules: array-neg-le-eq-2: ⊦ ar0 ≠ ar1 ∧ ar0 ≤ ar1 → ¬ ar1 ≤ ar0; Used terms: subarray(ar3, m + 1, n0)

Proof step 154 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 155:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar3[m] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

• Proof step 164:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar3[m] < ar[m], ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Proof step 155 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 156:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar3[m] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar3, m + 1, n0) ≠ subarray(ar, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ perm(a ' + x, a ' + y) ↔ perm(x, y); (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ a ' + x = b ' + y ↔ a = b ∧ x = y; (ws)

Proof step 156 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply lemma

And obtained the following new goals

• Proof step 157:

  ⊦ ordered≤(ar) → min(ar)

• Proof step 158:

  # ar0 = # ar, # ar = n0 + m + 1, ar3[m] = ar[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar3, m + 1, n0) ≠ subarray(ar, m + 1, n0), m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(subarray(ar3, m + 1, n0), subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ordered≤(subarray(ar, m + 1, n0)) → min(subarray(ar, m + 1, n0)), ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used terms: subarray(ar, m + 1, n0)

Proof step 157 from proof next-proper-permutation (previous step) (back to tree)

Lemma ascending-order-is-min-permuted

Proof step 158 from proof next-proper-permutation (previous step) (back to tree)

User applied rule case distinction

And obtained the following new goals

• Proof step 159:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar3[m] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar3, m + 1, n0) ≠ subarray(ar, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, min(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Proof step 159 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 160:

  ⊦ min(ar1) ↔ (∀ ar2. perm(ar1, ar2) → ar1 ≤ ar2)

• Proof step 161:

  # ar0 = # ar, # ar = n0 + m + 1, ar3[m] = ar[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar3, m + 1, n0) ≠ subarray(ar, m + 1, n0), m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(subarray(ar3, m + 1, n0), subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ ar2. perm(subarray(ar, m + 1, n0), ar2) → subarray(ar, m + 1, n0) ≤ ar2 ⊦

Rule argument

Additional information

Used terms: subarray(ar, m + 1, n0)

Proof step 160 from proof next-proper-permutation (previous step) (back to tree)

Lemma minimum-permutation

Proof step 161 from proof next-proper-permutation (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 162:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar3[m] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n0 ≠ 0, subarray(ar3, m + 1, n0) ≠ subarray(ar, m + 1, n0), m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, subarray(ar3, m + 1, n0) ≤ subarray(ar, m + 1, n0), perm(subarray(ar, m + 1, n0), subarray(ar3, m + 1, n0)) → subarray(ar, m + 1, n0) ≤ subarray(ar3, m + 1, n0), ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used terms: subarray(ar3, m + 1, n0)

Proof step 162 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 163:

  ⊦ perm(x, y) ↔ perm(y, x)

Rule argument

Additional information

Used simplifier rules: array-neg-le-eq-2: ⊦ ar0 ≠ ar1 ∧ ar0 ≤ ar1 → ¬ ar1 ≤ ar0; Used terms: subarray(ar, m + 1, n0), subarray(ar3, m + 1, n0)

Proof step 163 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 164 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 165:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ar3[m] < ar[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m +1 = m + 1; (s) ⊦ m < n → n ≠ 0; (s) lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic

Proof step 165 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 166:

  ⊦ perm(x, a ' + y) ↔ a ∈ x ∧ perm(x -1l a, y)

• Proof step 167:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar3[m] < ar[m], ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm((ar0[m] ' + subarray(ar0, m + 1, n0)) -1l ar3[m], subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), ar3[m] ∈ ar0[m] ' + subarray(ar0, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used terms: ar0[m] ' + subarray(ar0, m + 1, n0), ar3[m], subarray(ar3, m + 1, n0)

Proof step 166 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 167 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 168:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ar3[m] < ar[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), ar3[m] ∈ subarray(ar0, m + 1, n0), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ a ≠ b → (b ' + x) -1l a = b ' + (x -1l a); (s) ⊦ a ≠ b → (a ∈ b ' + x ↔ a ∈ x); (s)

Proof step 168 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 169:

  ⊦ a ∈ x ↔ (∃ n. n < # x ∧ x[n] = a)

• Proof step 170:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n0 ≠ 0, ar3[m] < ar[m], ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∃ n. n < # subarray(ar0, m + 1, n0) ∧ subarray(ar0, m + 1, n0)[n] = ar3[m] ⊦

Rule argument

Additional information

Used terms: ar3[m], subarray(ar0, m + 1, n0)

Proof step 169 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 170 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 171:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[(m + 1) + n] = ar3[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n < n0, ar3[m] < ar[m], ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), perm(ar3[m] ' + subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

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 lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ # subarray(ar, m, n) = n; (s)

Proof step 171 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 172:

  ⊦ perm(a ' + x, y) ↔ a ∈ y ∧ perm(x, y -1l a)

• Proof step 173:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], ar0[(m + 1) + n] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ar3[m] < ar[m], n < n0, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), perm(subarray(ar3, m + 1, n0), (ar[m] ' + subarray(ar, m + 1, n0)) -1l ar3[m]), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), ar3[m] ∈ ar[m] ' + subarray(ar, m + 1, n0), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used terms: ar3[m], subarray(ar3, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)

Proof step 172 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 173 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 174:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[(m + 1) + n] = ar3[m], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n < n0, ar3[m] < ar[m], ar0[m] < ar3[m], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), ar3[m] ∈ subarray(ar, m + 1, n0), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Used simplifier rules: trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] a: ⊦ (x + y) + z = x + y + z; from specification list[natarray-oarray-sort] ⊦ a ≠ b → (b ' + x) -1l a = b ' + (x -1l a); (s) ⊦ a ≠ b → (a ∈ b ' + x ↔ a ∈ x); (s)

Proof step 174 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 175:

  ⊦ a ∈ x ↔ (∃ n. n < # x ∧ x[n] = a)

• Proof step 176:

  # ar0 = # ar, # ar = n0 + m + 1, ar0[j0] = ar[m], ar0[(m + 1) + n] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar3[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ar3[m] < ar[m], n < n0, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∃ n. n < # subarray(ar, m + 1, n0) ∧ subarray(ar, m + 1, n0)[n] = ar3[m] ⊦

Rule argument

Additional information

Used terms: ar3[m], subarray(ar, m + 1, n0)

Proof step 175 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 176 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 177:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar3[m], ar0[j0] = ar[m], ar0[(m + 1) + n] = ar3[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar3[m] ' + subarray(ar3, m + 1, n0), ar3[m] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar3[m] ≠ ar[m], ar0[m] ≠ ar3[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar3[m], ar3[m] < ar[m], n < n0, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar3[m])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar3[m]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ # subarray(ar, m, n) = n; (s)

Proof step 177 from proof next-proper-permutation (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 178:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n < n0, ar0[(m + 1) + n] < ar[m], ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m] ⊦

Rule argument

Additional information

Proof step 178 from proof next-proper-permutation (previous step) (back to tree)

User applied rule cut formula

And obtained the following new goals

• Proof step 179:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, n < j0 - m + 1, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

• Proof step 191:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ¬ n < j0 - m + 1, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used formulas: n < j0 - m + 1

Proof step 179 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 180:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, 2 + n + m < # ar3, n + m + 1 < # ar3, n < n0, ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, n + m + 1 < j0, ar0[(m + 1) + n] < ar[m], 2 + n + m < # ar, n + 1 < n0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m], ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[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 n0 < n ⊦ m + (* n) < m0 + (* n0) ↔ m + (n - n0) < m0; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m +1 = m + 1; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 180 from proof next-proper-permutation (previous step) (back to tree)

User applied rule weakening

And obtained the following new goals

• Proof step 181:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n + 1 < n0, 2 + n + m < # ar, ar0[(m + 1) + n] < ar[m], n + m + 1 < j0, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], n < n0, n + m + 1 < # ar3, 2 + n + m < # ar3, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i ⊦

Rule argument

Additional information

Proof step 181 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 182:

  ⊦ ordered≤(rev(ar)) ↔ (∀ m, n. m ≤ n ∧ n < # ar → ¬ ar[m] < ar[n])

• Proof step 183:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, 2 + n + m < # ar3, n + m + 1 < # ar3, n < n0, ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, n + m + 1 < j0, ar0[(m + 1) + n] < ar[m], 2 + n + m < # ar, n + 1 < n0, ordered≤(subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ m0, n. m0 ≤ n ∧ n < # subarray(ar0, m + 1, n0) → ¬ subarray(ar0, m + 1, n0)[m0] < subarray(ar0, m + 1, n0)[n] ⊦

Rule argument

Additional information

Used terms: subarray(ar0, m + 1, n0)

Proof step 182 from proof next-proper-permutation (previous step) (back to tree)

Lemma ordered-all-rev

Proof step 183 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 184:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n + 1 < n0, 2 + n + m < # ar, ar0[(m + 1) + n] < ar[m], n + m + 1 < j0, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], n < n0, n + m + 1 < # ar3, 2 + n + m < # ar3, ordered≤(subarray(ar, m + 1, n0)), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ m0, n2. m0 ≤ n2 ∧ n2 < n0 → ¬ subarray(ar0, m + 1, n0)[m0] < ar0[(m + 1) + n2] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ # subarray(ar, m, n) = n; (s)

Proof step 184 from proof next-proper-permutation (previous step) (back to tree)

User applied rule subst equation

And obtained the following new goals

• Proof step 185:

  # ar = n0 + m + 1, # ar0 = # ar, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar0[j0], ar0[m] ≠ ar0[j0], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, 2 + n + m < # ar3, n + m + 1 < # ar3, n < n0, ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar0[j0], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar0[j0], n1 < n0, n + m + 1 < j0, ar0[(m + 1) + n] < ar0[j0], 2 + n + m < # ar, n + 1 < n0, ordered≤(subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ∀ m0, n2. m0 ≤ n2 ∧ n2 < n0 → ¬ subarray(ar0, m + 1, n0)[m0] < ar0[(m + 1) + n2] ⊦

Rule argument

Additional information

Proof step 185 from proof next-proper-permutation (previous step) (back to tree)

User applied rule apply rewrite lemma

And obtained the following new goals

• Proof step 186:

  ⊦ m < n ↔ (∃ m0. m + m0 = n ∧ m0 ≠ 0)

• Proof step 187:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar0[j0], ar0[m] ≠ ar0[j0], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar0[j0]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n + 1 < n0, 2 + n + m < # ar, ar0[(m + 1) + n] < ar0[j0], n + m + 1 < j0, n1 < n0, ar0[m] + 1 < ar0[j0], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar0[j0], j0 < # ar, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], n < n0, n + m + 1 < # ar3, 2 + n + m < # ar3, ordered≤(subarray(ar, m + 1, n0)), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ m0, n2. m0 ≤ n2 ∧ n2 < n0 → ¬ subarray(ar0, m + 1, n0)[m0] < ar0[(m + 1) + n2], ∃ m0. m + m0 = j0 ∧ m0 ≠ 0 ⊦

Rule argument

Additional information

Used terms: m, j0

Proof step 186 from proof next-proper-permutation (previous step) (back to tree)

A spec-lemma

Proof step 187 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 188:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[m] ≠ ar0[m + m0], ar0[(m + 1) + n] ≠ ar0[m + m0], ar ≠ [], ar0 ≠ ar0[m, ar0[m + m0]][m + m0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n + 1 < m0, n1 < n0, m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], n < n0, n + m + 1 < # ar3, 2 + n + m < # ar3, 2 + n + m < # ar, ar0[(m + 1) + n] < ar0[m + m0], n + 1 < n0, m + m0 < # ar, m + m0 < # ar3, ar0[m] < ar0[m + m0], ar0[m] + 1 < ar0[m + m0], ordered≤(subarray(ar, m + 1, n0)), # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, m0 ≤ n0, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ m0, n2. m0 ≤ n2 ∧ n2 < n0 → ¬ subarray(ar0, m + 1, n0)[m0] < ar0[(m + 1) + n2] ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ m +1 = m + 1; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m < n → n ≠ 0; (s) lel: ⊦ a < b ∧ a = c → c < b; (forward) from specification oelem[natarray] lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic transitivity: ⊦ a < b ∧ b < c → a < c; (forward) from specification oelem[natarray] fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s)

Proof step 188 from proof next-proper-permutation (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 189:

  # ar = n0 + m + 1, # ar0 = # ar, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[m] ≠ ar0[m + m0], ar0[(m + 1) + n] ≠ ar0[m + m0], ar ≠ [], ar0 ≠ ar0[m, ar0[m + m0]][m + m0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], ar0[m] + 1 < ar0[m + m0], ar0[m] < ar0[m + m0], m + m0 < # ar3, m + m0 < # ar, n + 1 < n0, ar0[(m + 1) + n] < ar0[m + m0], 2 + n + m < # ar, 2 + n + m < # ar3, n + m + 1 < # ar3, n < n0, ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, n1 < n0, n + 1 < m0, ordered≤(subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, m0 ≤ n0, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, n ≤ m0 - 1 ∧ m0 - 1 < n0 → ¬ subarray(ar0, m + 1, n0)[n] < ar0[(m + 1) + (m0 - 1)] ⊦

Rule argument

Additional information

Used terms: n, m0 - 1

Proof step 189 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 190:

  # ar = n0 + m + 1, # ar0 = # ar, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar0[m + m0], ar0[m] ≠ ar0[m + m0], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar0[m + m0]][m + m0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, ar0[m] + 1 < ar0[m + m0], ar0[m] < ar0[m + m0], m + m0 < # ar3, m + m0 < # ar, n + 1 < n0, ar0[(m + 1) + n] < ar0[m + m0], 2 + n + m < # ar, 2 + n + m < # ar3, n + m + 1 < # ar3, ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, n1 < n0, n + 1 < m0, n < m0, n < n0, ar0[(m + 1) + (m0 - 1)] < ar0[m + m0], ordered≤(subarray(ar, m + 1, n0)), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, m0 ≤ n0, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, ar0[(m + 1) + (m0 - 1)] ≤ ar0[(m + 1) + n] ⊦

Rule argument

Additional information

Used simplifier rules: fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat ⊦ 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 → ¬ m + m0 < n; (s) ⊦ n0 < n → subarray(ar, m, n)[n0] = ar[m + n0]; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s) ⊦ m < n → n ≠ 0; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m + 1 ≤ n ↔ m < n; (s) n0 ≤ n ⊦ m ≤ n - n0 ↔ m + n0 ≤ n; (s)

Proof step 190 from proof next-proper-permutation (previous step) (back to tree)

Heuristic elimination applied rule apply elim lemma

And closed the goal!

Rule argument

Additional information

Used simplifier rules: ⊦ m + 1 ≠ 0; (s) ⊦ 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) ⊦ n + 0 = n; (s) n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: m0, m1

Proof step 191 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 192:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), j0 ≤ n + m + 1, # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 ≤ n ∧ n < # ar → ar0[m, ar[m]][j0, ar0[m]][n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[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 < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m < n → n ≠ 0; (s) trans: ⊦ perm(x, y) ∧ perm(y, z) → perm(x, z); (forward) from specification list-perm[natarray-oarray-sort] lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m + 1 ≤ n ↔ m < n; (s)

Proof step 192 from proof next-proper-permutation (previous step) (back to tree)

User applied rule all left

And obtained the following new goals

• Proof step 193:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[m] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n < n0, ar0[(m + 1) + n] < ar[m], ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, j0 ≤ n + m + 1, j0 ≤ (m + 1) + n ∧ (m + 1) + n < # ar → ar0[m, ar[m]][j0, ar0[m]][(m + 1) + n] < ar[m], ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used terms: (m + 1) + n

Proof step 193 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 194:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, ar0[m, ar[m]][j0, ar0[m]][(m + 1) + n] < ar[m], n < n0, ar0[(m + 1) + n] < ar[m], ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, j0 ≤ n + m + 1, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

Used simplifier rules: lf-01: ⊦ m < n ∧ n = n0 → m < n0; (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 = m0 + n0 ∧ n < n0 → m0 + n < m; (s)

Proof step 194 from proof next-proper-permutation (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 195:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), (m + 1) + n ≠ j0, ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[(m + 1) + n] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[m] ≠ ar[m], ar ≠ [], ar0 ≠ ar, ar0 ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar3 ≠ [], ar3 ≠ ar0, ar3 ≠ ar, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, ar0[m, ar[m]][j0, ar0[m]][(m + 1) + n] < ar[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), j0 ≤ n + m + 1, # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

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 Used formulas: (m + 1) + n = j0

Proof step 195 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 196:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), (m + 1) + n ≠ j0, ar0[m] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n ≠ 0, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, ar0[m, ar[m]][(m + 1) + n] < ar[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), j0 ≤ n + m, # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[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 < m + n ↔ n ≠ 0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m ≠ n → ar[n, a][m] = ar[m]; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m ≠ n → (m ≤ n ↔ m < n); (s)

Proof step 196 from proof next-proper-permutation (previous step) (back to tree)

Heuristic nonsplitting cut applied rule cut formula

And obtained the following new goals

• Proof step 197:

  # ar = n0 + m + 1, # ar0 = # ar, ar0[j0] = ar[m], ar[(m + 1) + n1] = ar0[(m + 1) + n], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), (m + 1) + n ≠ m, ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), (m + 1) + n ≠ j0, ar0[m] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n ≠ 0, ar0[m, ar[m]][(m + 1) + n] < ar[m], n < n0, ar0[(m + 1) + n] < ar[m], ar0[m] < ar0[(m + 1) + n], m + n0 < # ar, m < # ar, m + 1 < # ar, j < # ar, m < j0, j0 < # ar, ar0[m] < ar[m], ar0[m] < ar0[m + 1], i < # ar, m < i, i < # ar3, j < # ar3, j0 < # ar3, m + n0 < # ar3, m < # ar3, m + 1 < # ar3, ar0[m] + 1 < ar[m], n1 < n0, ordered≤(rev(subarray(ar0, m + 1, n0))), ordered≤(subarray(ar, m + 1, n0)), perm(ar0, ar), perm(ar0, ar3), perm(ar3, ar), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), j ≤ i, i ≤ n0 + m, j ≤ n0 + m, j0 ≤ n0 + m, ar0 ≤ ar3, ar3 ≤ ar, ar0 ≤ ar, # ar ≤ # ar3, j0 ≤ n + m, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[m] ⊦

Rule argument

Additional information

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

Proof step 197 from proof next-proper-permutation (previous step) (back to tree)

Heuristic simplifier applied rule simplifier

And obtained the following new goals

• Proof step 198:

  # ar0 = # ar, # ar = n0 + m + 1, ar[(m + 1) + n1] = ar0[(m + 1) + n], ar0[j0] = ar[m], rev(subarray(ar0[m, ar[m]][j0, ar0[m]], m + 1, n0)) = subarray(ar, m + 1, n0), subarray(ar0, 0, m) = subarray(ar, 0, m), ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0) ≠ ar[m] ' + subarray(ar, m + 1, n0), ar0[m] ' + subarray(ar0, m + 1, n0) ≠ ar0[(m + 1) + n] ' + subarray(ar3, m + 1, n0), (m + 1) + n ≠ j0, ar0[m] ≠ ar[m], ar0[m] ≠ ar0[(m + 1) + n], ar0[(m + 1) + n] ≠ ar[m], ar ≠ [], ar0 ≠ ar0[m, ar[m]][j0, ar0[m]], ar0 ≠ [], ar0 ≠ ar, ar3 ≠ ar, ar3 ≠ ar0, ar3 ≠ [], n ≠ 0, n1 < n0, ar0[m] + 1 < ar[m], m + 1 < # ar3, m < # ar3, m + n0 < # ar3, j0 < # ar3, j < # ar3, i < # ar3, m < i, i < # ar, ar0[m] < ar0[m + 1], ar0[m] < ar[m], j0 < # ar, m < j0, j < # ar, m + 1 < # ar, m < # ar, m + n0 < # ar, ar0[m] < ar0[(m + 1) + n], ar0[(m + 1) + n] < ar[m], n < n0, ar0[m, ar[m]][(m + 1) + n] < ar[m], ordered≤(subarray(ar, m + 1, n0)), ordered≤(rev(subarray(ar0, m + 1, n0))), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(subarray(ar3, m + 1, n0), ar[m] ' + (subarray(ar, m + 1, n0) -1l ar0[(m + 1) + n])), perm(ar0[m] ' + (subarray(ar0, m + 1, n0) -1l ar0[(m + 1) + n]), subarray(ar3, m + 1, n0)), perm(ar0[m] ' + subarray(ar0, m + 1, n0), ar[m] ' + subarray(ar, m + 1, n0)), perm(ar3, ar), perm(ar0, ar3), perm(ar0, ar), j0 ≤ n + m, # ar ≤ # ar3, ar0 ≤ ar, ar3 ≤ ar, ar0 ≤ ar3, j0 ≤ n0 + m, j ≤ n0 + m, i ≤ n0 + m, j ≤ i, ∀ n. j0 < n ∧ n < # ar → ar0[n] ≤ ar0[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 + 1 ≠ 0; (s) ⊦ m = m + n ↔ n = 0; (s)

Proof step 198 from proof next-proper-permutation (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 + 1 ↔ ¬ n < m; (s) ⊦ m ≤ n → (n < m ↔ false); (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: (m + 1) + n