| nx1 = nx, nx3 = nx, wlar0 = wlar1, nx0.head < # wlar, valid-indices(wlar1, nx), ∃ nx. (nx3 = nx + nx0 ∧ wlar = wlar1.mapIndices(nx, λ wle. wle.ec:= n) ∧ valid-indices(wlar, nx) ∧ ¬ dups(nx3)) ∧ nx0 = nx2 ⊦ nx0 = [], dups(nx), ∃ nx1. ( nx3 = nx1 + nx0.tail ∧ wlar[nx0.head, wlar[nx0.head].ec:= n] = wlar1.mapIndices(nx1, λ wle. wle.ec:= n) ∧ valid-indices(wlar[nx0.head, wlar[nx0.head].ec:= n], nx1) ∧ ¬ dups(nx3)) ∧ # nx0.tail < # nx2 |
nx2.head < # wlar1.mapIndices(nx4, λ wle. wle.ec:= n), valid-indices(wlar1, nx2), valid-indices(wlar1, nx4), valid-indices(wlar1.mapIndices(nx4, λ wle. wle.ec:= n), nx4) ⊦ nx2 = [], dups(nx2), dups(nx4), dups(nx4 + nx2), ∃ nx. nx4 + nx2 = nx + nx2.tail ∧ wlar1.mapIndices(nx4, λ wle. wle.ec:= n)[nx2.head, wlar1.mapIndices(nx4, λ wle. wle.ec:= n)[nx2.head].ec:= n] = wlar1.mapIndices(nx, λ wle. wle.ec:= n) ∧ valid-indices(wlar1.mapIndices(nx4, λ wle. wle.ec:= n), nx)
Used simplifier rules: ⊦ m < n → n ≠ 0; (s)%a: ⊦ ¬ dups(nx + nx0) → ¬ dups(nx) ∧ ¬ dups(nx0); (forward) from specification list-dup[nat-list-set]%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 < n; (s)% ⊦ m < n + 1 ↔ ¬ n < m; (s)%n0 ≤ n ⊦ n - n0 < m ↔ n < m + n0; (s)% ⊦ # nx = 0 ↔ nx = []; (s)% ⊦ m < 1 ↔ m = 0; (s)% ⊦ m ≤ n ↔ ¬ n < m; (ss)% ⊦ n -1 = n - 1; (s)% ⊦ nx ≠ [] → # nx.tail = (# nx)-1; (s)% ⊦ valid-indices(wlar[n, wle], nx) ↔ valid-indices(wlar, nx); (s)%a: ⊦ (nx + nx0) + nx1 = nx + nx0 + nx1; from specification list[nat-list-set]%⊦ valid-indices(wlar, nx0 + nx1) ↔ valid-indices(wlar, nx0) ∧ valid-indices(wlar, nx1); (ws)