openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionCallbacks.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedDictionaryCallback | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedWeights | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.StreamWitness | |
| namespace OAI | |
| /-! # Executed fixed-width callbacks for the compression join | |
| The left dictionary keeps its distinct-key count in the safe state. It never | |
| traverses the trie to count entries during insertion. The right callback | |
| computes one fixed-width key and one trie lookup. | |
| -/ | |
| namespace LowSpaceSubsetSum.CompressionCallbacks | |
| variable {n : ℕ} | |
| def weightCode (I : Instance n) (x : ℤ) : List Bool × ℕ := | |
| let m := CountedWeights.natBits (2 * inputScale I) x.natAbs | |
| (decide (x < 0) :: m.1, m.2 + 3) | |
| theorem weightCode_value (I : Instance n) (x : ℤ) : | |
| (weightCode I x).1 = WeightEncoding.weightKey I x := by | |
| simp only [weightCode, CountedWeights.natBits_value, | |
| WeightEncoding.weightKey, WeightEncoding.signedBits] | |
| theorem weightCode_width (I : Instance n) (x : ℤ) : | |
| (weightCode I x).1.length = WeightEncoding.weightWidth I := by | |
| rw [weightCode_value, WeightEncoding.weightKey_length] | |
| theorem weightCode_work (I : Instance n) (x : ℤ) : | |
| (weightCode I x).2 = 6 * inputScale I + 4 := by | |
| simp only [weightCode, CountedWeights.natBits, CountedWeights.bits_work] | |
| omega | |
| abbrev Dictionary (I : Instance n) (C : ℕ) := | |
| CountedDictionaryCallback.SafeState C (WeightEncoding.weightWidth I) (weightCode I) | |
| def empty (I : Instance n) (C : ℕ) : Dictionary I C := | |
| CountedDictionaryCallback.empty _ _ _ | |
| def report (I : Instance n) (C : ℕ) (x y : ℤ) (state : Dictionary I C) : | |
| (Dictionary I C × Bool) × ℕ := | |
| CountedDictionaryCallback.callback C (WeightEncoding.weightWidth I) (weightCode I) | |
| (weightCode_width I) (fun _ => 1) (fun a b => (some (a + b), 1)) x y state | |
| theorem report_value (I : Instance n) (C : ℕ) (x y : ℤ) (state : Dictionary I C) : | |
| ((report I C x y state).1.1.val.keys, (report I C x y state).1.2) = | |
| BinaryTrie.callback C (fun a b => WeightEncoding.weightKey I (a + b)) x y state.val.keys := by | |
| change ((CountedDictionaryCallback.feed C (WeightEncoding.weightWidth I) (weightCode I) | |
| (weightCode_width I) (fun _ => 1) (x + y) state).1.val.keys, false) = _ | |
| rw [CountedDictionaryCallback.feed_value] | |
| simp only [RecordedDictionary.feed_keys, weightCode_value, BinaryTrie.callback] | |
| theorem report_work (I : Instance n) (C : ℕ) (x y : ℤ) (state : Dictionary I C) : | |
| (report I C x y state).2 ≤ 10 * inputScale I + 27 := by | |
| have h := CountedDictionaryCallback.callback_work C (WeightEncoding.weightWidth I) | |
| (weightCode I) (weightCode_width I) (fun _ => 1) (fun a b : ℤ => (some (a + b), 1)) | |
| (6 * inputScale I + 4) 1 1 (fun a => (weightCode_work I a).le) | |
| (fun _ => le_rfl) (fun _ _ => le_rfl) x y state | |
| change (report I C x y state).2 ≤ _ at h | |
| unfold WeightEncoding.weightWidth at h | |
| omega | |
| def probe (I : Instance n) (tree : BinaryTrie.Tree) (target x y : ℤ) (found : Bool) : | |
| (Bool × Bool) × ℕ := | |
| let k := weightCode I (target - (x + y)) | |
| let hit := CountedTrie.contains tree k.1 | |
| ((found || hit.1, false), k.2 + hit.2 + 5) | |
| theorem probe_value (I : Instance n) (tree : BinaryTrie.Tree) (target x y : ℤ) (found : Bool) : | |
| (probe I tree target x y found).1 = | |
| StreamWitness.remember | |
| (fun x y => BinaryTrie.contains tree (WeightEncoding.weightKey I (target - (x + y)))) | |
| x y found := by | |
| simp only [probe, CountedTrie.contains_value, weightCode_value, StreamWitness.remember] | |
| theorem probe_work (I : Instance n) (tree : BinaryTrie.Tree) (target x y : ℤ) (found : Bool) : | |
| (probe I tree target x y found).2 ≤ 8 * inputScale I + 11 := by | |
| have h := CountedTrie.contains_work tree (weightCode I (target - (x + y))).1 | |
| rw [weightCode_width] at h | |
| change (weightCode I (target - (x + y))).2 + _ + 5 ≤ _ | |
| rw [weightCode_work] | |
| unfold WeightEncoding.weightWidth at h | |
| omega | |
| theorem report_scale (I : Instance n) (hn : 10000 ≤ n) (C : ℕ) | |
| (x y : ℤ) (state : Dictionary I C) : | |
| (report I C x y state).2 ≤ inputScale I ^ 2 := by | |
| have hu : 10000 ≤ inputScale I := by unfold inputScale; omega | |
| exact (report_work I C x y state).trans (by nlinarith only [hu]) | |
| theorem probe_scale (I : Instance n) (hn : 10000 ≤ n) | |
| (tree : BinaryTrie.Tree) (target x y : ℤ) (found : Bool) : | |
| (probe I tree target x y found).2 ≤ inputScale I ^ 2 := by | |
| have hu : 10000 ≤ inputScale I := by unfold inputScale; omega | |
| exact (probe_work I tree target x y found).trans (by nlinarith only [hu]) | |
| theorem storage (I : Instance n) (C : ℕ) (state : Dictionary I C) : | |
| state.val.records.size ≤ C + 1 ∧ | |
| BinaryTrie.nodes state.val.keys.tree ≤ (2 * inputScale I + 2) * (C + 1) := by | |
| simpa only [WeightEncoding.weightWidth, Nat.add_assoc] using | |
| RecordedDictionary.storage state.property | |
| end LowSpaceSubsetSum.CompressionCallbacks | |
| end OAI | |