openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /PreparedSeparatorExpectation.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.PreparedSeparatorContext | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorSamplerCoupling | |
| namespace OAI | |
| /-! # The measured checker under the actual independent family law | |
| The ideal subset draws are identified with their stored bit codes. Decoding | |
| these codes preserves every sampled occurrence, so the existing scan | |
| expectation applies to the measured checker without changing its law. | |
| -/ | |
| noncomputable section | |
| namespace LowSpaceSubsetSum.PreparedSeparatorExpectation | |
| open SeparatorExpectation RepresentationMoments | |
| variable {n g : ℕ} (S : RoundedParameters g) | |
| private instance sampleNonempty (i : Fin 4) : | |
| Nonempty (SeparatorSample (Finset.univ : Finset (Fin g)) (S.e i)) := | |
| ⟨⟨initialSubset g (S.e i) (S.size_le i), | |
| Finset.mem_powersetCard.mpr ⟨Finset.subset_univ _, initialSubset_card _ _ _⟩⟩⟩ | |
| def codes (draws : IndependentFamilies g S.e S.counts) : Fin 4 → Array (Fin (2 ^ g)) := | |
| fun i => (familyArrays draws i).map SeparatorStoredMasks.code | |
| theorem codes_size (draws : IndependentFamilies g S.e S.counts) (i : Fin 4) : | |
| (codes S draws i).size ≤ 11 * 2 ^ g := by | |
| simpa only [codes, familyArrays, Array.size_map, Array.size_ofFn] using S.counts_le i | |
| theorem codes_decode (draws : IndependentFamilies g S.e S.counts) : | |
| (fun i => (codes S draws i).map SeparatorStoredMasks.decode) = familyArrays draws := by | |
| funext i | |
| simp only [codes, Array.map_map] | |
| have h : SeparatorStoredMasks.decode ∘ SeparatorStoredMasks.code = | |
| (id : Finset (Fin g) → Finset (Fin g)) := by | |
| funext a | |
| exact SeparatorStoredMasks.decode_code a | |
| rw [h, Array.map_id] | |
| def prepare (rows : Fin 4 → Vector (Fin n) g) | |
| (draws : IndependentFamilies g S.e S.counts) : List (StoredSeparatorCheck.Block n g) × ℕ := | |
| PreparedSeparatorContext.prepare rows (codes S draws) (codes_size S draws) | |
| def check (rows : Fin 4 → Vector (Fin n) g) | |
| (draws : IndependentFamilies g S.e S.counts) | |
| (capacity : ℕ) (target : ℤ) (xs ys : List (StoredEntry n)) : Bool × ℕ := | |
| StoredSeparatorCheck.run capacity target (prepare S rows draws).1 xs ys | |
| theorem acceptance (C : TopCoordinates n g) | |
| (rows : Fin 4 → Vector (Fin n) g) (hrows : ∀ i j, (rows i)[j] = C.index (i, j)) | |
| (draws : IndependentFamilies g S.e S.counts) | |
| (capacity : ℕ) (hcap : capacity = 2 ^ n) (target : ℤ) | |
| (xs ys : List (StoredEntry n)) : | |
| (check S rows draws capacity target xs ys).1 = | |
| (C.check (familyArrays draws) target | |
| (xs.map StoredEntry.semantic) (ys.map StoredEntry.semantic)).accepted := by | |
| have h := PreparedSeparatorContext.acceptance C rows hrows (codes S draws) | |
| (codes_size S draws) capacity hcap target xs ys | |
| rw [codes_decode] at h | |
| exact h | |
| theorem check_work (I : Instance n) (hn : 10000 ≤ n) (hg : g ≤ n) | |
| (C : TopCoordinates n g) | |
| (rows : Fin 4 → Vector (Fin n) g) (hrows : ∀ i j, (rows i)[j] = C.index (i, j)) | |
| (draws : IndependentFamilies g S.e S.counts) | |
| (capacity : ℕ) (hcap : capacity = 2 ^ n) (target : ℤ) | |
| (xs ys : List (StoredEntry n)) : | |
| (check S rows draws capacity target xs ys).2 ≤ inputScale I ^ 4 * | |
| ((C.check (familyArrays draws) target | |
| (xs.map StoredEntry.semantic) (ys.map StoredEntry.semantic)).scans + | |
| xs.length + ys.length + 1) := by | |
| have h := PreparedSeparatorContext.run_work I hn hg C rows hrows (codes S draws) | |
| (codes_size S draws) capacity hcap target xs ys | |
| rw [codes_decode] at h | |
| exact h | |
| theorem prepare_work (I : Instance n) (hn : 10000 ≤ n) (hg : g ≤ n) | |
| (C : ℕ) (hC : 2 ^ (2 * g) ≤ C) | |
| (rows : Fin 4 → Vector (Fin n) g) (draws : IndependentFamilies g S.e S.counts) : | |
| (prepare S rows draws).2 ≤ inputScale I ^ 2 * C := | |
| PreparedSeparatorContext.prepare_work_scale I hn hg C hC rows (codes S draws) | |
| (codes_size S draws) | |
| theorem mean_check_work (I : Instance n) (hn : 10000 ≤ n) (hg : g ≤ n) | |
| (C : TopCoordinates n g) | |
| (rows : Fin 4 → Vector (Fin n) g) (hrows : ∀ i j, (rows i)[j] = C.index (i, j)) | |
| (capacity : ℕ) (hcap : capacity = 2 ^ n) (target : ℤ) | |
| (xs ys : List (StoredEntry n)) | |
| (hleft : ∀ x ∈ xs, ∀ i, | |
| (SeparatorCheck.localMask i (C.encodeEntry x.semantic).mask).card = S.c i) | |
| (hright : ∀ y ∈ ys, ∀ i, | |
| (SeparatorCheck.localMask i (C.encodeEntry y.semantic).mask).card = g / 2 - S.c i) : | |
| mean (fun draws : IndependentFamilies g S.e S.counts => | |
| ((check S rows draws capacity target xs ys).2 : ℝ)) ≤ | |
| (inputScale I : ℝ) ^ 4 * | |
| (((xs.length + ys.length : ℕ) : ℝ) * (inputScale I : ℝ) ^ 22 * | |
| (2 : ℝ) ^ (((4 * g : ℕ) : ℝ) * (1 - binaryEntropy (1 / 4))) + | |
| ((xs.length + ys.length : ℕ) : ℝ) + 1) := by | |
| have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega | |
| have hscan := C.mean_scans_polynomial S (inputScale I) (by omega) (by omega) (by omega) | |
| target (xs.map StoredEntry.semantic) (ys.map StoredEntry.semantic) | |
| (by | |
| intro x hx i | |
| obtain ⟨x, hxMem, rfl⟩ := List.mem_map.mp hx | |
| exact hleft x hxMem i) | |
| (by | |
| intro y hy i | |
| obtain ⟨y, hyMem, rfl⟩ := List.mem_map.mp hy | |
| exact hright y hyMem i) | |
| simp only [List.length_map] at hscan | |
| have hpoint (draws : IndependentFamilies g S.e S.counts) : | |
| ((check S rows draws capacity target xs ys).2 : ℝ) ≤ | |
| (inputScale I : ℝ) ^ 4 * | |
| (((C.check (familyArrays draws) target | |
| (xs.map StoredEntry.semantic) (ys.map StoredEntry.semantic)).scans : ℝ) + | |
| ((xs.length + ys.length : ℕ) : ℝ) + 1) := by | |
| have hw := check_work S I hn hg C rows hrows draws capacity hcap target xs ys | |
| simp only [Nat.add_assoc] at hw | |
| exact_mod_cast hw | |
| have hm := mean_mono hpoint | |
| simp_rw [mean_mul_left, mean_add, mean_const] at hm | |
| exact hm.trans (mul_le_mul_of_nonneg_left (by linarith) (by positivity)) | |
| end LowSpaceSubsetSum.PreparedSeparatorExpectation | |
| end | |
| end OAI | |