| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedRepresentationEmit |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredDictionaryJoin |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| The readers, modular keys, validity tests, signed sums, dictionary encoding |
| and mutable snapshots below execute their counted implementations. The bound |
| uses the counters of that same stopped run, including invalid reported tuples. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.CountedParentJoin |
|
|
| variable {n : ℕ} |
|
|
| abbrev Child (n : ℕ) := LeafRecord n × LeafRecord n |
|
|
| def cells (x : Child n) : ℕ := |
| x.1.top.indices.length + x.1.localMask.indices.length + x.1.background.indices.length + |
| x.2.top.indices.length + x.2.localMask.indices.length + x.2.background.indices.length + 4 |
|
|
| theorem cells_le (x : Child n) : cells x ≤ 6 * n + 4 := by |
| have h1 := x.1.top.length_le |
| have h2 := x.1.localMask.length_le |
| have h3 := x.1.background.length_le |
| have h4 := x.2.top.length_le |
| have h5 := x.2.localMask.length_le |
| have h6 := x.2.background.length_le |
| unfold cells |
| omega |
|
|
| abbrev State (I : Instance n) (F : IndexedMask n) (P : ℤ) |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) (d : ℕ) := |
| MergedReader.State (fun x => (RepresentationKeys.pairKey I F P mode x).1) |
| (FilteredStream.view right) d |
|
|
| /-- Deep-copy the mutable tournament; the immutable right array is shared. -/ |
| def snapshot (I : Instance n) (F : IndexedMask n) (P : ℤ) |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} |
| (s : State I F P mode right d) : State I F P mode right d × ℕ := |
| let out := Tournament.countedCopy (12 * n + 32) s.tree |
| have he : out.1 = s.tree := Tournament.countedCopy_value _ _ |
| (⟨out.1, he.symm ▸ s.valid, he.symm ▸ s.aligned, he.symm ▸ s.sorted⟩, out.2) |
|
|
| theorem snapshot_value (I : Instance n) (F : IndexedMask n) (P : ℤ) |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} |
| (s : State I F P mode right d) : (snapshot I F P mode right s).1 = s := by |
| cases s |
| simp only [snapshot, Tournament.countedCopy_value] |
|
|
| theorem snapshot_work (I : Instance n) (F : IndexedMask n) (P : ℤ) |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} |
| (s : State I F P mode right d) : |
| (snapshot I F P mode right s).2 ≤ (12 * n + 32) * 2 ^ (d + 1) := by |
| have he := Tournament.nodes_exact s.tree |
| simp only [snapshot, Tournament.countedCopy_cells] |
| exact Nat.mul_le_mul_left _ (by omega) |
|
|
| private theorem report_polynomial {n u : ℕ} (hnu : n ≤ u) (hu : 10000 ≤ u) : |
| u ^ 3 + 12 * u ^ 2 + (n + 2) + 2 * (3 * u + 1) + 19 ≤ u ^ 4 := by |
| have hu1 : 1 ≤ u := by omega |
| have h12 : u ≤ u ^ 2 := by simpa using Nat.pow_le_pow_right hu1 (by decide : 1 ≤ 2) |
| have h23 : u ^ 2 ≤ u ^ 3 := Nat.pow_le_pow_right hu1 (by decide) |
| have hlow : (n + 2) + 2 * (3 * u + 1) + 19 ≤ 30 * u ^ 3 := by omega |
| have hscale : 43 * u ^ 3 ≤ u ^ 4 := by |
| calc |
| _ ≤ u * u ^ 3 := Nat.mul_le_mul_right _ (by omega) |
| _ = _ := (pow_succ' u 3).symm |
| omega |
|
|
| theorem report_work (I : Instance n) (F : IndexedMask n) (C : ℕ) |
| (x y : Child n) (r : StoredEntry.Dictionary I C) (hn : 10000 ≤ n) : |
| (StoredEntry.report I C (CountedRepresentationEmit.emit I F) x y r).2 ≤ |
| inputScale I ^ 4 := by |
| have h := StoredEntry.report_work I C (inputScale I ^ 3) |
| (CountedRepresentationEmit.emit I F) |
| (fun x y => CountedRepresentationEmit.emit_scale I F x y hn) x y r |
| have hw := (WeightEncoding.widths_le I).2 |
| have hnu : n ≤ inputScale I := by unfold inputScale; omega |
| exact h.trans ((Nat.add_le_add_right |
| (Nat.add_le_add_left (Nat.mul_le_mul_left 2 hw) _) 19).trans |
| (report_polynomial hnu (hn.trans hnu))) |
| |
| def run (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ) |
| (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ} |
| (fuel₁ fuel₂ control : ℕ) (s₁ : State I F P .direct right₁ d₁) |
| (s₂ : State I F P (.complementary t) right₂ d₂) := |
| StoredDictionaryJoin.run I C |
| (RepresentationKeys.read I F P .direct right₁) (RepresentationKeys.pairKey I F P .direct) |
| (RepresentationKeys.read I F P (.complementary t) right₂) |
| (RepresentationKeys.pairKey I F P (.complementary t)) cells |
| (CountedRepresentationEmit.emit I F) (snapshot I F P (.complementary t) right₂) |
| B fuel₁ fuel₂ control s₁ s₂ |
|
|
| private theorem query_polynomial {n u : ℕ} (hnu : n ≤ u) (hu : 10000 ≤ u) : |
| 2 * (u ^ 5 + u ^ 5 + u ^ 3 + u ^ 3 + (6 * n + 4)) + 131 ≤ u ^ 6 := by |
| have hu1 : 1 ≤ u := by omega |
| have h15 : u ≤ u ^ 5 := by simpa using Nat.pow_le_pow_right hu1 (by decide : 1 ≤ 5) |
| have h35 : u ^ 3 ≤ u ^ 5 := Nat.pow_le_pow_right hu1 (by decide) |
| have hconst : 139 ≤ 139 * u ^ 5 := by |
| exact Nat.le_mul_of_pos_right _ (by positivity) |
| have hscale : 160 * u ^ 5 ≤ u ^ 6 := by |
| calc |
| _ ≤ u * u ^ 5 := Nat.mul_le_mul_right _ (by omega) |
| _ = _ := (pow_succ' u 5).symm |
| omega |
|
|
| /-- Work is charged to the actual query/report/snapshot counters, on every |
| run, without a successful sampling or valid-record hypothesis. -/ |
| theorem run_work (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ) |
| (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ} |
| (fuel₁ fuel₂ control : ℕ) (s₁ : State I F P .direct right₁ d₁) |
| (s₂ : State I F P (.complementary t) right₂ d₂) |
| (hn : 10000 ≤ n) (hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n) |
| (hcopy : (12 * n + 32) * 2 ^ (d₂ + 1) ≤ B) : |
| let out := run I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ |
| out.2 ≤ inputScale I ^ 6 * (out.1.state.queries + out.1.state.reports + 1) + |
| B * out.1.state.copies := by |
| let read₁ := RepresentationKeys.read I F P .direct right₁ (d := d₁) |
| let read₂ := RepresentationKeys.read I F P (.complementary t) right₂ (d := d₂) |
| let key₁ := RepresentationKeys.pairKey I F P .direct |
| let key₂ := RepresentationKeys.pairKey I F P (.complementary t) |
| let report := StoredEntry.report I C (CountedRepresentationEmit.emit I F) |
| let clone := snapshot I F P (.complementary t) right₂ (d := d₂) |
| let out := run I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ |
| have hc : ∀ s, (clone s).1 = s := snapshot_value I F P (.complementary t) right₂ |
| have hw := CountedStreamJoin.run_work_queries read₁ key₁ read₂ key₂ cells report clone hc |
| (inputScale I ^ 5) (inputScale I ^ 5) (inputScale I ^ 3) (inputScale I ^ 3) |
| (6 * n + 4) (inputScale I ^ 4) B |
| (fun s => RepresentationKeys.read_scale I F P .direct right₁ s hd₁ hn) |
| (fun s => RepresentationKeys.read_scale I F P (.complementary t) right₂ s hd₂ hn) |
| (fun x => RepresentationKeys.pairKey_scale I F P .direct x hn) |
| (fun y => RepresentationKeys.pairKey_scale I F P (.complementary t) y hn) |
| cells_le (fun x y a => report_work I F C x y a hn) |
| (fun s => (snapshot_work I F P (.complementary t) right₂ s).trans hcopy) |
| B fuel₁ fuel₂ control s₁ s₂ (StoredEntry.empty I C) |
| have hv := congrArg StreamJoin.StoppedResult.state |
| (CountedStreamJoin.runAcc_value read₁ key₁ read₂ key₂ cells report clone hc |
| B fuel₁ fuel₂ control (StreamJoin.start s₁ s₂ (StoredEntry.empty I C))) |
| rw [StreamJoin.stoppedAcc_eq] at hv |
| change out.1.state = StreamJoin.run _ _ _ _ _ _ _ _ _ _ _ _ at hv |
| rw [← hv] at hw |
| change out.2 ≤ _ at hw |
| change out.2 ≤ inputScale I ^ 6 * (out.1.state.queries + out.1.state.reports + 1) + |
| B * out.1.state.copies |
| have hnu : n ≤ inputScale I := by unfold inputScale; omega |
| have hu : 10000 ≤ inputScale I := hn.trans hnu |
| have hq := Nat.mul_le_mul_right out.1.state.queries (query_polynomial hnu hu) |
| have hr := Nat.mul_le_mul_right out.1.state.reports |
| (Nat.pow_le_pow_right (by omega : 0 < inputScale I) (by decide : 4 ≤ 6)) |
| have h1 : 1 ≤ inputScale I ^ 6 := Nat.one_le_pow _ _ (by omega) |
| simp only [Nat.mul_add, Nat.mul_one] |
| omega |
|
|
| end LowSpaceSubsetSum.CountedParentJoin |
|
|
| end OAI |
|
|
