openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Storage /IntervalDomainCells.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.IntervalDomainExecution | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredFilterCells | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredSortCells | |
| namespace OAI | |
| /-! # Live storage for arithmetic interval domain construction | |
| The scan tests only the two interval endpoints. It filters the bounded | |
| index list, looks up the stored permutation, and sorts the resulting | |
| indices. The immutable permutation array is shared throughout. | |
| -/ | |
| namespace LowSpaceSubsetSum.IntervalDomainCells | |
| variable {n : ℕ} | |
| def test (start len : ℕ) (i : Fin n) : (Bool × ℕ) × ℕ := | |
| ((decide (start ≤ i.val ∧ i.val < start+len), 2), 8) | |
| def positions (n start len : ℕ) : List (Fin n) × ℕ := | |
| let r := MeasuredFilterCells.run (test start len) (List.finRange n) | |
| (r.1.1, r.2+2*n+8) | |
| theorem positions_value (n start len : ℕ) : | |
| (positions n start len).1 = IntervalDomainExecution.positions n start len := by | |
| simp only [positions, MeasuredFilterCells.run_value, MeasuredFilter.runAcc_value, | |
| List.reverse_nil, List.nil_append, test, IntervalDomainExecution.positions] | |
| theorem positions_length (n start len : ℕ) : (positions n start len).1.length ≤ n := by | |
| rw [positions_value] | |
| simpa only [IntervalDomainExecution.positions, List.length_finRange] using | |
| List.length_filter_le (fun i : Fin n => decide (start ≤ i.val ∧ i.val < start+len)) | |
| (List.finRange n) | |
| theorem positions_length_interval (n start len : ℕ) (h : start+len ≤ n) : | |
| (positions n start len).1.length = len := by | |
| rw [positions_value] | |
| have hn := (List.nodup_finRange n).filter | |
| (fun i : Fin n => decide (start ≤ i.val ∧ i.val < start+len)) | |
| have hs : (IntervalDomainExecution.positions n start len).toFinset = | |
| indexInterval n start len := by | |
| ext i | |
| simp only [IntervalDomainExecution.positions, List.mem_toFinset, List.mem_filter, | |
| List.mem_finRange, true_and, decide_eq_true_eq, indexInterval, Finset.mem_filter, | |
| Finset.mem_univ] | |
| have hc := List.toFinset_card_of_nodup hn | |
| change (IntervalDomainExecution.positions n start len).toFinset.card = | |
| (IntervalDomainExecution.positions n start len).length at hc | |
| rw [hs, indexInterval_card h] at hc | |
| exact hc.symm | |
| theorem positions_cells (n start len : ℕ) : (positions n start len).2 ≤ 4*n+20 := by | |
| have h := MeasuredFilterCells.run_cells (test start len) 8 (fun _ => le_rfl) (List.finRange n) | |
| simp only [List.length_finRange] at h | |
| change _+2*n+8 ≤ _ | |
| omega | |
| def map (v : Vector (Fin n) n) : List (Fin n) → List (Fin n) × ℕ | |
| | [] => ([], 4) | |
| | i :: xs => | |
| let r := map v xs | |
| (v[i.val]::r.1, r.2+8) | |
| theorem map_value (v : Vector (Fin n) n) (xs : List (Fin n)) : | |
| (map v xs).1 = xs.map (fun i => v[i.val]) := by | |
| induction xs with | |
| | nil => rfl | |
| | cons i xs ih => simp only [map, List.map_cons, ih] | |
| theorem map_cells (v : Vector (Fin n) n) (xs : List (Fin n)) : | |
| (map v xs).2 ≤ 8*xs.length+4 := by | |
| induction xs with | |
| | nil => exact le_rfl | |
| | cons i xs ih => simp only [map, List.length_cons]; omega | |
| def compare (x y : Fin n) : (Bool × ℕ) × ℕ := ((decide (x ≤ y), 1), 4) | |
| def run (v : Vector (Fin n) n) (start len : ℕ) : (List (Fin n) × ℕ) × ℕ := | |
| let ps := positions n start len | |
| let xs := map v ps.1 | |
| let sorted := MeasuredSortCells.run 1 compare (Nat.clog 2 xs.1.length) xs.1 | |
| ((sorted.1.1, sorted.1.2+8*(n+1)^2), ps.2+xs.2+sorted.2+4*(n+1)) | |
| theorem run_value (v : Vector (Fin n) n) (start len : ℕ) : | |
| (run v start len).1 = IntervalDomainExecution.run v start len := by | |
| simp only [run, MeasuredSortCells.run_value, map_value, positions_value, | |
| IntervalDomainExecution.run, MeasuredSort.sort, compare] | |
| theorem run_length (v : Vector (Fin n) n) (start len : ℕ) (h : start+len ≤ n) : | |
| (run v start len).1.1.length = len := by | |
| rw [run_value] | |
| simp only [IntervalDomainExecution.run, MeasuredSort.sort_value, List.length_mergeSort, | |
| List.length_map] | |
| simpa only [positions_value] using positions_length_interval n start len h | |
| theorem run_cells (v : Vector (Fin n) n) (start len : ℕ) : | |
| (run v start len).2 ≤ 128*(n+1)^2 := by | |
| let ps := positions n start len | |
| let xs := map v ps.1 | |
| have hp := positions_cells n start len | |
| have hm := map_cells v ps.1 | |
| have hl := positions_length n start len | |
| have hxs : xs.1.length ≤ n := by | |
| dsimp only [xs] | |
| rw [map_value, List.length_map] | |
| exact hl | |
| have hd : Nat.clog 2 xs.1.length ≤ n := | |
| Nat.clog_le_of_le_pow (hxs.trans (Nat.lt_two_pow_self (n := n)).le) | |
| have hs := MeasuredSortCells.run_cells 1 compare 4 (fun _ _ => le_rfl) | |
| (Nat.clog 2 xs.1.length) xs.1 | |
| have hcoef : 24*(1+2)*(xs.1.length+1)+4 ≤ 76*(n+1) := by omega | |
| have hs' := hs.trans (Nat.mul_le_mul (show Nat.clog 2 xs.1.length+1 ≤ n+1 by omega) hcoef) | |
| change ps.2+xs.2+_+4*(n+1) ≤ _ | |
| change ps.2 ≤ _ at hp | |
| change xs.2 ≤ _ at hm | |
| change ps.1.length ≤ n at hl | |
| nlinarith only [hp, hm, hl, hs'] | |
| end LowSpaceSubsetSum.IntervalDomainCells | |
| end OAI | |