| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.SliceCursor |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.BinaryPivot |
| import Mathlib.Data.List.TakeDrop |
|
|
| namespace OAI |
|
|
| /-! |
| # Binary search for the exact eligible slice |
|
|
| Two prefix searches find the half-open interval of occurrences with a fixed |
| primary key. A secondary order within equal primary keys gives the sorted |
| slice needed by modular row initialization. Both searches query the shared |
| array directly, including when the eligible slice is empty. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
| namespace BinarySlice |
|
|
| variable {α : Type*} |
|
|
| def lower (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) : ℕ := |
| (BinaryPivot.search (fun i : Fin xs.size => decide (key xs[i.val] < r)) k).lo |
|
|
| def upper (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) : ℕ := |
| (BinaryPivot.search (fun i : Fin xs.size => decide (key xs[i.val] ≤ r)) k).lo |
|
|
| theorem lower_spec (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) : |
| ∀ i : Fin xs.size, key xs[i.val] < r ↔ i.val < lower xs key r k := by |
| have hp : BinaryPivot.PrefixPredicate |
| (fun i : Fin xs.size => decide (key xs[i.val] < r)) := by |
| intro i j hij hj |
| exact decide_eq_true ((hs hij).trans_lt (of_decide_eq_true hj)) |
| simpa only [lower, decide_eq_true_eq] using |
| (BinaryPivot.search_exact _ hp k hk).2 |
|
|
| theorem upper_spec (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) : |
| ∀ i : Fin xs.size, key xs[i.val] ≤ r ↔ i.val < upper xs key r k := by |
| have hp : BinaryPivot.PrefixPredicate |
| (fun i : Fin xs.size => decide (key xs[i.val] ≤ r)) := by |
| intro i j hij hj |
| exact decide_eq_true ((hs hij).trans (of_decide_eq_true hj)) |
| simpa only [upper, decide_eq_true_eq] using |
| (BinaryPivot.search_exact _ hp k hk).2 |
|
|
| theorem lower_bounded (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) : |
| lower xs key r k ≤ xs.size := |
| (BinaryPivot.search _ k).ordered.trans (BinaryPivot.search _ k).bounded |
|
|
| theorem upper_bounded (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) : |
| upper xs key r k ≤ xs.size := |
| (BinaryPivot.search _ k).ordered.trans (BinaryPivot.search _ k).bounded |
|
|
| theorem ordered (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) : |
| lower xs key r k ≤ upper xs key r k := by |
| by_contra h |
| have hlow := lower_bounded xs key r k |
| have hin : upper xs key r k < xs.size := by omega |
| have hlt := (lower_spec xs key r k hs hk ⟨_, hin⟩).mpr (by dsimp; omega) |
| have hle := (upper_spec xs key r k hs hk ⟨_, hin⟩).mp hlt.le |
| change upper xs key r k < upper xs key r k at hle |
| omega |
|
|
| def range (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) : |
| SliceCursor.Range xs.size := |
| ⟨lower xs key r k, upper xs key r k - lower xs key r k, by |
| have := ordered xs key r k hs hk |
| have := upper_bounded xs key r k |
| omega⟩ |
|
|
| theorem index_spec (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) |
| (i : Fin xs.size) : |
| key xs[i.val] = r ↔ lower xs key r k ≤ i.val ∧ i.val < upper xs key r k := by |
| have hl := lower_spec xs key r k hs hk i |
| have hu := upper_spec xs key r k hs hk i |
| omega |
|
|
| theorem slice_eq_filter (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) : |
| SliceCursor.slice xs (range xs key r k hs hk) = |
| xs.toList.filter (fun x => decide (key x = r)) := by |
| let lo := lower xs key r k |
| let hi := upper xs key r k |
| have hlo : lo ≤ hi := ordered xs key r k hs hk |
| have hhi : hi ≤ xs.size := upper_bounded xs key r k |
| let pre := xs.toList.take lo |
| let mid := (xs.toList.drop lo).take (hi - lo) |
| let suf := xs.toList.drop hi |
| have hdec : xs.toList = pre ++ mid ++ suf := by |
| have hd : mid ++ suf = xs.toList.drop lo := by |
| dsimp only [mid, suf] |
| have heq : lo + (hi - lo) = hi := by omega |
| simpa only [heq] using List.drop_take_append_drop xs.toList lo (hi - lo) |
| rw [List.append_assoc, hd] |
| exact (List.take_append_drop lo xs.toList).symm |
| have hp : pre.filter (fun x => decide (key x = r)) = [] := by |
| apply List.filter_eq_nil_iff.mpr |
| intro x hx |
| obtain ⟨i, hi', hix⟩ := List.mem_iff_getElem.mp hx |
| have hin : i < xs.size := by |
| dsimp only [pre] at hi' |
| simp only [List.length_take, Array.length_toList] at hi' |
| omega |
| have hil : i < lo := by |
| dsimp only [pre] at hi' |
| simp only [List.length_take, Array.length_toList] at hi' |
| omega |
| have hv := (lower_spec xs key r k hs hk ⟨i, hin⟩).mpr hil |
| dsimp only [pre] at hix |
| rw [List.getElem_take, Array.getElem_toList] at hix |
| rw [← hix] |
| simpa only [decide_eq_true_eq] using ne_of_lt hv |
| have hm : mid.filter (fun x => decide (key x = r)) = mid := by |
| apply List.filter_eq_self.mpr |
| intro x hx |
| obtain ⟨i, hi', hix⟩ := List.mem_iff_getElem.mp hx |
| have hin : lo + i < xs.size := by |
| dsimp only [mid] at hi' |
| simp only [List.length_take, List.length_drop, Array.length_toList] at hi' |
| omega |
| have hili : lo + i < hi := by |
| dsimp only [mid] at hi' |
| simp only [List.length_take, List.length_drop, Array.length_toList] at hi' |
| omega |
| have hv := (index_spec xs key r k hs hk ⟨lo + i, hin⟩).mpr ⟨by dsimp; omega, hili⟩ |
| dsimp only [mid] at hix |
| rw [List.getElem_take, List.getElem_drop, Array.getElem_toList] at hix |
| rw [← hix] |
| exact decide_eq_true hv |
| have ht : suf.filter (fun x => decide (key x = r)) = [] := by |
| apply List.filter_eq_nil_iff.mpr |
| intro x hx |
| obtain ⟨i, hi', hix⟩ := List.mem_iff_getElem.mp hx |
| have hin : hi + i < xs.size := by |
| dsimp only [suf] at hi' |
| simp only [List.length_drop, Array.length_toList] at hi' |
| omega |
| have hv : ¬ key xs[hi + i] ≤ r := by |
| intro hle |
| have := (upper_spec xs key r k hs hk ⟨hi + i, hin⟩).mp hle |
| change hi + i < hi at this |
| omega |
| dsimp only [suf] at hix |
| rw [List.getElem_drop, Array.getElem_toList] at hix |
| rw [← hix] |
| simpa only [decide_eq_true_eq] using |
| (show ¬ key xs[hi + i] = r from fun heq => hv heq.le) |
| rw [SliceCursor.slice_eq_drop_take] |
| change mid = xs.toList.filter _ |
| rw [hdec, List.filter_append, List.filter_append, hp, hm, ht] |
| simp |
| |
| theorem slice_key (xs : Array α) (key : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) |
| (i : Fin (range xs key r k hs hk).length) : |
| key (SliceCursor.values xs (range xs key r k hs hk) i) = r := by |
| have hmem : SliceCursor.values xs (range xs key r k hs hk) i ∈ |
| SliceCursor.slice xs (range xs key r k hs hk) := List.mem_ofFn.mpr ⟨i, rfl⟩ |
| rw [slice_eq_filter xs key r k hs hk] at hmem |
| exact of_decide_eq_true (List.mem_filter.mp hmem).2 |
| |
| theorem slice_sorted (xs : Array α) (key secondary : α → ℤ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => key xs[i.val])) (hk : xs.size < 2 ^ k) |
| (htie : ∀ i j : Fin xs.size, i ≤ j → key xs[i.val] = key xs[j.val] → |
| secondary xs[i.val] ≤ secondary xs[j.val]) : |
| Monotone (fun i : Fin (range xs key r k hs hk).length => |
| secondary (SliceCursor.values xs (range xs key r k hs hk) i)) := by |
| intro i j hij |
| let rr := range xs key r k hs hk |
| have hi : rr.lo + i.val < xs.size := by |
| have := rr.bounded |
| have : i.val < rr.length := i.isLt |
| omega |
| have hj : rr.lo + j.val < xs.size := by |
| have := rr.bounded |
| have : j.val < rr.length := j.isLt |
| omega |
| apply htie ⟨rr.lo + i.val, hi⟩ ⟨rr.lo + j.val, hj⟩ |
| (show rr.lo + i.val ≤ rr.lo + j.val from Nat.add_le_add_left hij _) |
| exact (slice_key xs key r k hs hk i).trans (slice_key xs key r k hs hk j).symm |
| |
| end BinarySlice |
| end LowSpaceSubsetSum |
| |
| end OAI |
| |
