| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredPivotCells |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationRecordInitialization |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationKeyCells |
|
|
| namespace OAI |
|
|
| /-! # Explicit scratch for the three searches initializing a stored row |
|
|
| Range endpoints and modular pivots use tail binary search on the retained |
| right array. Only one weight evaluation is live at any time. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.MeasuredRowCells |
|
|
| variable {α : Type*} |
|
|
| def range (xs : Array α) (key : α → (ℤ × ℕ) × ℕ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1.1)) |
| (hk : xs.size < 2 ^ k) : (SliceCursor.Range xs.size × ℕ) × ℕ := |
| let lo := MeasuredPivotCells.search (fun i : Fin xs.size => |
| let q := key xs[i.val]; ((decide (q.1.1 < r), q.1.2 + 2), q.2 + 8)) k |
| let hi := MeasuredPivotCells.search (fun i : Fin xs.size => |
| let q := key xs[i.val]; ((decide (q.1.1 ≤ r), q.1.2 + 2), q.2 + 8)) k |
| have hlo : lo.1.1.lo = BinarySlice.lower xs (fun x => (key x).1.1) r k := by |
| simp only [lo, MeasuredPivotCells.search_value, BinarySlice.lower, |
| BinaryPivot.measuredSearch_value] |
| have hhi : hi.1.1.lo = BinarySlice.upper xs (fun x => (key x).1.1) r k := by |
| simp only [hi, MeasuredPivotCells.search_value, BinarySlice.upper, |
| BinaryPivot.measuredSearch_value] |
| ((⟨lo.1.1.lo, hi.1.1.lo - lo.1.1.lo, by |
| rw [hlo, hhi] |
| exact (BinarySlice.range xs (fun x => (key x).1.1) r k hs hk).bounded⟩, |
| lo.1.2 + hi.1.2 + 4), max lo.2 hi.2 + 24) |
|
|
| theorem range_value (xs : Array α) (key : α → (ℤ × ℕ) × ℕ) (r : ℤ) (k : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1.1)) (hk : xs.size < 2 ^ k) : |
| (range xs key r k hs hk).1 = BinarySlice.measuredRange xs (fun x => (key x).1) r k hs hk := by |
| simp only [range, BinarySlice.measuredRange, MeasuredPivotCells.search_value] |
|
|
| theorem range_cells (xs : Array α) (key : α → (ℤ × ℕ) × ℕ) (r : ℤ) (k R : ℕ) |
| (hs : Monotone (fun i : Fin xs.size => (key xs[i.val]).1.1)) (hk : xs.size < 2 ^ k) |
| (hr : ∀ x, (key x).2 ≤ R) : (range xs key r k hs hk).2 ≤ R + 72 := by |
| have hl := MeasuredPivotCells.search_cells (fun i : Fin xs.size => |
| let q := key xs[i.val]; ((decide (q.1.1 < r), q.1.2 + 2), q.2 + 8)) (R + 8) |
| (fun i => Nat.add_le_add_right (hr xs[i.val]) 8) k |
| have hh := MeasuredPivotCells.search_cells (fun i : Fin xs.size => |
| let q := key xs[i.val]; ((decide (q.1.1 ≤ r), q.1.2 + 2), q.2 + 8)) (R + 8) |
| (fun i => Nat.add_le_add_right (hr xs[i.val]) 8) k |
| change max _ _ + 24 ≤ _ |
| omega |
|
|
| def start (xs : Array α) (rr : SliceCursor.Range xs.size) (key : α → (ℤ × ℕ) × ℕ) |
| (P r : ℤ) (k : ℕ) (reverse : Bool) : (SliceCursor.State xs.size × ℕ) × ℕ := |
| if h : 0 < rr.length then |
| haveI : NeZero rr.length := ⟨by omega⟩ |
| let q := MeasuredPivotCells.search (fun i : Fin rr.length => |
| let w := key (SliceCursor.values xs rr i) |
| ((if reverse then decide (w.1.1 ≤ r) else decide (w.1.1 < P - r), w.1.2 + 2), w.2 + 8)) k |
| let pos := if reverse then Fin.ofNat rr.length q.1.1.lo - 1 else Fin.ofNat rr.length q.1.1.lo |
| ((⟨rr, some ⟨pos, rr.length, reverse⟩⟩, q.1.2 + 8), q.2 + 32) |
| else ((⟨rr, none⟩, 1), 16) |
|
|
| theorem start_value (xs : Array α) (rr : SliceCursor.Range xs.size) (key : α → (ℤ × ℕ) × ℕ) |
| (P r : ℤ) (k : ℕ) (reverse : Bool) : |
| (start xs rr key P r k reverse).1 = |
| if reverse then SliceModular.measuredReverse xs rr (fun x => (key x).1) r k |
| else SliceModular.measuredForward xs rr (fun x => (key x).1) P r k := by |
| cases reverse <;> |
| simp only [start, Bool.false_eq_true, ↓reduceIte, SliceModular.measuredForward, |
| SliceModular.measuredReverse, ModularCursor.measuredForward, ModularCursor.measuredReverse] |
| all_goals split <;> simp only [MeasuredPivotCells.search_value] |
|
|
| theorem start_cells (xs : Array α) (rr : SliceCursor.Range xs.size) (key : α → (ℤ × ℕ) × ℕ) |
| (P r : ℤ) (k R : ℕ) (reverse : Bool) (hr : ∀ x, (key x).2 ≤ R) : |
| (start xs rr key P r k reverse).2 ≤ R + 80 := by |
| unfold start |
| split |
| · rename_i h |
| have : NeZero rr.length := ⟨by omega⟩ |
| have hh := MeasuredPivotCells.search_cells (fun i : Fin rr.length => |
| let w := key (SliceCursor.values xs rr i) |
| ((if reverse then decide (w.1.1 ≤ r) else decide (w.1.1 < P - r), w.1.2 + 2), w.2 + 8)) |
| (R + 8) (fun i => Nat.add_le_add_right (hr (SliceCursor.values xs rr i)) 8) k |
| dsimp only at hh ⊢ |
| omega |
| · dsimp only; omega |
|
|
| variable {n : ℕ} |
|
|
| def row (I : Instance n) (F : IndexedMask n) (right : Array (LeafRecord n)) (p P c : ℤ) |
| (hs : FilteredRow.PrimarySorted right (fun x => (RepresentationKeys.leafWeight I F x).1) p) |
| (mode : FilteredStream.Mode) (x : LeafRecord n) : |
| (PairCursor.State (LeafRecord n) right.size × ℕ) × ℕ := |
| let wx := RepresentationKeyCells.leafWeight I F x |
| let k := FilteredStream.steps right.size |
| let low := fun y => let w := RepresentationKeyCells.leafWeight I F y |
| ((w.1.1 % p, w.1.2 + 2), w.2 + 8) |
| let high := fun y => let w := RepresentationKeyCells.leafWeight I F y |
| ((w.1.1 % P, w.1.2 + 2), w.2 + 8) |
| let rr := range right low ((c - wx.1.1) % p) k |
| (by simpa only [low, FilteredRow.PrimarySorted, RepresentationKeyCells.leafWeight_value] using hs) |
| (FilteredStream.steps_sufficient right.size) |
| let q := match mode with |
| | .direct => start right rr.1.1 high P (wx.1.1 % P) k false |
| | .complementary v => start right rr.1.1 high P ((v - wx.1.1) % P) k true |
| ((⟨x, q.1.1⟩, wx.1.2 + rr.1.2 + q.1.2 + 4), max wx.2 (max rr.2 q.2) + 3 * n + 68) |
|
|
| theorem row_value (I : Instance n) (F : IndexedMask n) (right : Array (LeafRecord n)) (p P c : ℤ) |
| (hs : FilteredRow.PrimarySorted right (fun x => (RepresentationKeys.leafWeight I F x).1) p) |
| (mode : FilteredStream.Mode) (x : LeafRecord n) : |
| (row I F right p P c hs mode x).1 = RepresentationKeys.row I F right p P c hs mode x := by |
| cases mode <;> |
| simp only [row, RepresentationKeys.row, FilteredStream.measuredRow, |
| range_value, start_value, RepresentationKeyCells.leafWeight_value, Bool.false_eq_true, ↓reduceIte] |
|
|
| theorem row_cells (I : Instance n) (F : IndexedMask n) (right : Array (LeafRecord n)) (p P c : ℤ) |
| (hs : FilteredRow.PrimarySorted right (fun x => (RepresentationKeys.leafWeight I F x).1) p) |
| (mode : FilteredStream.Mode) (x : LeafRecord n) : |
| (row I F right p P c hs mode x).2 ≤ 200 * inputScale I := by |
| have hw := RepresentationKeyCells.leafWeight_cells I F x |
| have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega |
| let low := fun y => let w := RepresentationKeyCells.leafWeight I F y |
| ((w.1.1 % p, w.1.2 + 2), w.2 + 8) |
| let high := fun y => let w := RepresentationKeyCells.leafWeight I F y |
| ((w.1.1 % P, w.1.2 + 2), w.2 + 8) |
| have hh : ∀ y, (high y).2 ≤ 12 * n + 32 := by |
| intro y |
| exact Nat.add_le_add_right (RepresentationKeyCells.leafWeight_cells I F y) 8 |
| have hl : ∀ y, (low y).2 ≤ 12 * n + 32 := by |
| intro y |
| exact Nat.add_le_add_right (RepresentationKeyCells.leafWeight_cells I F y) 8 |
| let k := FilteredStream.steps right.size |
| let rr := range right low ((c - (RepresentationKeyCells.leafWeight I F x).1.1) % p) k |
| (by simpa only [low, FilteredRow.PrimarySorted, RepresentationKeyCells.leafWeight_value] using hs) |
| (FilteredStream.steps_sufficient right.size) |
| have hr := range_cells right low ((c - (RepresentationKeyCells.leafWeight I F x).1.1) % p) |
| k (12 * n + 32) |
| (by simpa only [low, FilteredRow.PrimarySorted, RepresentationKeyCells.leafWeight_value] using hs) |
| (FilteredStream.steps_sufficient right.size) hl |
| change rr.2 ≤ _ at hr |
| cases mode with |
| | direct => |
| have hq := start_cells right rr.1.1 high P ((RepresentationKeyCells.leafWeight I F x).1.1 % P) |
| k (12 * n + 32) false hh |
| change max (RepresentationKeyCells.leafWeight I F x).2 |
| (max rr.2 (start right rr.1.1 high P ((RepresentationKeyCells.leafWeight I F x).1.1 % P) k false).2) + |
| 3 * n + 68 ≤ _ |
| omega |
| | complementary v => |
| have hq := start_cells right rr.1.1 high P ((v - (RepresentationKeyCells.leafWeight I F x).1.1) % P) |
| k (12 * n + 32) true hh |
| change max (RepresentationKeyCells.leafWeight I F x).2 |
| (max rr.2 (start right rr.1.1 high P ((v - (RepresentationKeyCells.leafWeight I F x).1.1) % P) k true).2) + |
| 3 * n + 68 ≤ _ |
| omega |
|
|
| end LowSpaceSubsetSum.MeasuredRowCells |
|
|
| end OAI |
|
|
