| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedParentCollector |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| These bounds use the intrinsic bounded-mask and safe-dictionary types. They |
| apply to intermediate callback states and reader snapshots, including after |
| the first overflowing insertion. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.ParentLiveState |
|
|
| variable {n : ℕ} |
|
|
| def reader {I : Instance n} {F : IndexedMask n} {P : ℤ} {mode : FilteredStream.Mode} |
| {right : Array (LeafRecord n)} {d : ℕ} (s : CountedParentJoin.State I F P mode right d) : ℕ := |
| (12 * n + 32) * (Tournament.nodes s.tree + 1) |
|
|
| theorem reader_exact {I : Instance n} {F : IndexedMask n} {P : ℤ} {mode : FilteredStream.Mode} |
| {right : Array (LeafRecord n)} {d : ℕ} (s : CountedParentJoin.State I F P mode right d) : |
| reader s = (12 * n + 32) * 2 ^ (d + 1) := by |
| simp only [reader, Tournament.nodes_exact] |
|
|
| def dictionary {I : Instance n} {C : ℕ} (r : StoredEntry.Dictionary I C) : ℕ := |
| (r.val.records.toList.map StoredEntry.cells).sum + r.val.records.size + |
| 3 * BinaryTrie.nodes r.val.keys.tree + 8 |
|
|
| private theorem list_cells (xs : List (StoredEntry n)) : |
| (xs.map StoredEntry.cells).sum ≤ (n + 2) * xs.length := by |
| induction xs with |
| | nil => simp |
| | cons x xs ih => |
| have h := x.cells_le |
| simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.mul_add, Nat.mul_one] |
| omega |
|
|
| theorem dictionary_le {I : Instance n} {C : ℕ} (r : StoredEntry.Dictionary I C) : |
| dictionary r ≤ (n + 3 + 3 * (WeightEncoding.entryWidth I + 1)) * (C + 1) + 8 := by |
| obtain ⟨hs, ht⟩ := RecordedDictionary.storage r.property |
| have hl := list_cells r.val.records.toList |
| simp only [Array.length_toList] at hl |
| have hm := Nat.mul_le_mul_left (n + 2) hs |
| have hn := Nat.mul_le_mul_left 3 ht |
| unfold dictionary |
| nlinarith only [hl, hs, hm, hn] |
|
|
| theorem dictionary_scale (I : Instance n) (C : ℕ) (r : StoredEntry.Dictionary I C) : |
| dictionary r ≤ 18 * inputScale I * (C + 1) + 8 := by |
| have hw := (WeightEncoding.widths_le I).2 |
| have hnu : n + 1 ≤ inputScale I := by unfold inputScale; omega |
| have hcoef : n + 3 + 3 * (WeightEncoding.entryWidth I + 1) ≤ 18 * inputScale I := by omega |
| exact (dictionary_le r).trans (Nat.add_le_add_right (Nat.mul_le_mul_right (C + 1) hcoef) 8) |
|
|
| def sharedArrays (left right : Array (LeafRecord n)) : ℕ := |
| (3 * n + 4) * (left.size + right.size + 1) |
|
|
| theorem sharedArrays_le (left right : Array (LeafRecord n)) (C : ℕ) |
| (hl : left.size ≤ C) (hr : right.size ≤ C) : |
| sharedArrays left right ≤ (3 * n + 4) * (2 * C + 1) := by |
| exact Nat.mul_le_mul_left _ (by omega) |
|
|
| def frame {I : Instance n} {F : IndexedMask n} {P t : ℤ} {C : ℕ} |
| {right₁ right₂ : Array (LeafRecord n)} {d₁ d₂ : ℕ} |
| (st : StreamJoin.State (CountedParentJoin.State I F P .direct right₁ d₁) |
| (CountedParentJoin.State I F P (.complementary t) right₂ d₂) |
| (StoredEntry.Dictionary I C)) : ℕ := |
| reader st.left + reader st.right + dictionary st.user + 12 |
|
|
| theorem frame_le {I : Instance n} {F : IndexedMask n} {P t : ℤ} {C : ℕ} |
| {right₁ right₂ : Array (LeafRecord n)} {d₁ d₂ : ℕ} |
| (st : StreamJoin.State (CountedParentJoin.State I F P .direct right₁ d₁) |
| (CountedParentJoin.State I F P (.complementary t) right₂ d₂) |
| (StoredEntry.Dictionary I C)) : |
| frame st ≤ (12 * n + 32) * (2 ^ (d₁ + 1) + 2 ^ (d₂ + 1)) + |
| 18 * inputScale I * (C + 1) + 20 := by |
| have h := dictionary_scale I C st.user |
| simp only [frame, reader_exact] |
| nlinarith only [h] |
|
|
| end LowSpaceSubsetSum.ParentLiveState |
|
|
| end OAI |
|
|
