openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Representation /RepresentationLeafWork.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedSubsets | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.StreamPrimitiveWork | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationTaskSpace | |
| namespace OAI | |
| /-! # Counted raw-leaf generation and sorting setup | |
| Feasibility is checked before constructing any component family. Conversion | |
| of an index list to a finite mask is charged quadratically in the ambient | |
| index count; every generated list has length at most that count. | |
| -/ | |
| namespace LowSpaceSubsetSum | |
| namespace RepresentationLeaf | |
| variable {n : ℕ} | |
| /-- Scan the ambient indices in order. The quadratic charge includes | |
| membership tests against a list representation of the finite domain. -/ | |
| def domainSort (V : Finset (Fin n)) : List (Fin n) × ℕ := | |
| ((List.finRange n).filter (fun i => decide (i ∈ V)), 2 * (n + 1) ^ 2) | |
| theorem domainSort_value (V : Finset (Fin n)) : (domainSort V).1 = V.sort (· ≤ ·) := by | |
| let l := (List.finRange n).filter (fun i => decide (i ∈ V)) | |
| have hn : l.Nodup := (List.nodup_finRange n).filter _ | |
| have hp : l.Pairwise (· ≤ ·) := | |
| ((List.sortedLT_finRange n).pairwise.imp (fun h => le_of_lt h)).filter _ | |
| have hf : l.toFinset = V := by ext; simp [l] | |
| have hs := (List.toFinset_sort (r := (· ≤ ·)) hn).mpr hp | |
| change l = V.sort (· ≤ ·) | |
| simpa only [hf] using hs.symm | |
| @[simp] theorem domainSort_length (V : Finset (Fin n)) : (domainSort V).1.length = V.card := by | |
| rw [domainSort_value, Finset.length_sort] | |
| theorem domainSort_work (V : Finset (Fin n)) : (domainSort V).2 ≤ 8 * (n + 1) ^ 2 := by | |
| change 2 * (n + 1) ^ 2 ≤ _ | |
| omega | |
| def countedEnumerate (L : RepresentationLeaf (Fin n)) : List (Occurrence (Fin n)) × ℕ := | |
| if L.topCount ≤ L.top.card ∧ L.localCount ≤ L.mixer.card then | |
| let dt := domainSort L.top | |
| let dm := domainSort L.mixer | |
| let db := domainSort L.background | |
| let ts := CountedSubsets.select L.topCount dt.1 | |
| let ms := CountedSubsets.select L.localCount dm.1 | |
| let bs := CountedSubsets.all db.1 | |
| let out := ((ts.1.map List.toFinset) ×ˢ (ms.1.map List.toFinset)) ×ˢ | |
| (bs.1.map List.toFinset) | |
| (out, dt.2 + dm.2 + db.2 + ts.2 + ms.2 + bs.2 + | |
| (n + 1) ^ 2 * (ts.1.length + ms.1.length + bs.1.length) + | |
| 4 * out.length + 3 * (n + 1)) | |
| else ([], 3 * (n + 1)) | |
| theorem countedEnumerate_value (L : RepresentationLeaf (Fin n)) : | |
| L.countedEnumerate.1 = L.enumerate := by | |
| unfold countedEnumerate | |
| split | |
| · simp only [domainSort_value, CountedSubsets.select_value, CountedSubsets.all_value] | |
| rfl | |
| · rename_i h | |
| symm | |
| apply List.eq_nil_of_length_eq_zero | |
| rw [enumerate_length, occurrences_card] | |
| rcases not_and_or.mp h with ht | hm | |
| · rw [Nat.choose_eq_zero_of_lt (Nat.lt_of_not_ge ht), zero_mul, zero_mul] | |
| · rw [Nat.choose_eq_zero_of_lt (Nat.lt_of_not_ge hm), mul_zero, zero_mul] | |
| theorem countedEnumerate_work (L : RepresentationLeaf (Fin n)) : | |
| L.countedEnumerate.2 ≤ 64 * (n + 1) ^ 2 * (L.occurrences.card + 1) := by | |
| by_cases h : L.topCount ≤ L.top.card ∧ L.localCount ≤ L.mixer.card | |
| · have hct : L.top.card ≤ n := by simpa using Finset.card_le_univ L.top | |
| have hcm : L.mixer.card ≤ n := by simpa using Finset.card_le_univ L.mixer | |
| have hcb : L.background.card ≤ n := by simpa using Finset.card_le_univ L.background | |
| let a := L.top.card.choose L.topCount | |
| let b := L.mixer.card.choose L.localCount | |
| let c := 2 ^ L.background.card | |
| let N := L.occurrences.card | |
| have ha : 1 ≤ a := Nat.choose_pos h.1 | |
| have hb : 1 ≤ b := Nat.choose_pos h.2 | |
| have hc : 1 ≤ c := Nat.one_le_two_pow | |
| have hN : N = a * b * c := L.occurrences_card | |
| have hab : 1 ≤ a * b := by nlinarith | |
| have haN : a ≤ N := by | |
| rw [hN] | |
| calc | |
| a ≤ a * b := by simpa using Nat.mul_le_mul_left a hb | |
| _ ≤ a * b * c := by simpa using Nat.mul_le_mul_left (a * b) hc | |
| have hbN : b ≤ N := by | |
| rw [hN] | |
| calc | |
| b ≤ a * b := by simpa using Nat.mul_le_mul_right b ha | |
| _ ≤ a * b * c := by simpa using Nat.mul_le_mul_left (a * b) hc | |
| have hcN : c ≤ N := by rw [hN]; simpa using Nat.mul_le_mul_right c hab | |
| have ht := CountedSubsets.select_work L.topCount (domainSort L.top).1 (by simpa using h.1) | |
| have hm := CountedSubsets.select_work L.localCount (domainSort L.mixer).1 (by simpa using h.2) | |
| have hbwork := CountedSubsets.all_work (domainSort L.background).1 | |
| simp only [domainSort_length] at ht hm hbwork | |
| have hta : (CountedSubsets.select L.topCount (domainSort L.top).1).2 ≤ | |
| 4 * (n + 1) ^ 2 * N := ht.trans (Nat.mul_le_mul | |
| (Nat.mul_le_mul_left 4 (Nat.pow_le_pow_left (by omega : L.top.card + 1 ≤ n + 1) 2)) haN) | |
| have hmb : (CountedSubsets.select L.localCount (domainSort L.mixer).1).2 ≤ | |
| 4 * (n + 1) ^ 2 * N := hm.trans (Nat.mul_le_mul | |
| (Nat.mul_le_mul_left 4 (Nat.pow_le_pow_left (by omega : L.mixer.card + 1 ≤ n + 1) 2)) hbN) | |
| have hbc : (CountedSubsets.all (domainSort L.background).1).2 ≤ 4 * N := | |
| hbwork.trans (Nat.mul_le_mul_left 4 hcN) | |
| have hd0 := domainSort_work L.top | |
| have hd1 := domainSort_work L.mixer | |
| have hd2 := domainSort_work L.background | |
| have hsum : a + b + c ≤ 3 * N := by omega | |
| have hprod : (n + 1) ^ 2 * (a + b + c) ≤ 3 * (n + 1) ^ 2 * N := by | |
| nlinarith [Nat.mul_le_mul_left ((n + 1) ^ 2) hsum] | |
| have hp : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| have hpn : N ≤ (n + 1) ^ 2 * N := by nlinarith | |
| have hnp : n + 1 ≤ (n + 1) ^ 2 := by nlinarith only [Nat.zero_le n] | |
| simp only [Nat.mul_assoc] at hta hmb hprod | |
| unfold countedEnumerate | |
| simp only [h, List.length_product, List.length_map, | |
| CountedSubsets.select_length, CountedSubsets.all_length, domainSort_length] | |
| change _ + _ + _ + _ + _ + _ + (n + 1) ^ 2 * (a + b + c) + | |
| 4 * (a * b * c) + 3 * (n + 1) ≤ 64 * (n + 1) ^ 2 * (N + 1) | |
| rw [← hN] | |
| calc | |
| _ ≤ 27 * (n + 1) ^ 2 + 11 * ((n + 1) ^ 2 * N) + 8 * N := by | |
| omega | |
| _ ≤ 27 * (n + 1) ^ 2 + 19 * ((n + 1) ^ 2 * N) := by omega | |
| _ ≤ _ := by nlinarith only [Nat.zero_le ((n + 1) ^ 2 * N), Nat.zero_le ((n + 1) ^ 2)] | |
| · simp only [countedEnumerate, h, ↓reduceIte] | |
| have hp : n + 1 ≤ (n + 1) ^ 2 := by nlinarith | |
| nlinarith [Nat.zero_le ((n + 1) ^ 2 * L.occurrences.card)] | |
| /-- The filter counter records predicate calls and output-array writes. | |
| The cost of the predicate itself is handled separately. -/ | |
| def countedArray (L : RepresentationLeaf (Fin n)) (accept : Occurrence (Fin n) → Bool) : | |
| Array (Occurrence (Fin n)) × ℕ := | |
| let e := L.countedEnumerate | |
| ((e.1.filter accept).toArray, e.2 + 2 * e.1.length) | |
| theorem countedArray_value (L : RepresentationLeaf (Fin n)) | |
| (accept : Occurrence (Fin n) → Bool) : | |
| (L.countedArray accept).1 = (L.enumerate.filter accept).toArray := by | |
| simp only [countedArray, countedEnumerate_value] | |
| theorem countedArray_work (L : RepresentationLeaf (Fin n)) | |
| (accept : Occurrence (Fin n) → Bool) : | |
| (L.countedArray accept).2 ≤ 68 * (n + 1) ^ 2 * (L.occurrences.card + 1) := by | |
| have he := L.countedEnumerate_work | |
| have hp : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| have hm : L.occurrences.card ≤ (n + 1) ^ 2 * (L.occurrences.card + 1) := by | |
| nlinarith [Nat.mul_le_mul_right (L.occurrences.card + 1) hp] | |
| simp only [countedArray, countedEnumerate_value, enumerate_length] | |
| nlinarith only [he, hm] | |
| end RepresentationLeaf | |
| namespace RepresentationPairData | |
| variable {n : ℕ} (D : RepresentationPairData n) | |
| /-- Counted generation, prefix filtering, and sorting of the two stored | |
| leaf arrays. No row is materialized by this setup. -/ | |
| def countedArrays : (Array (Occ (n := n)) × Array (Occ (n := n))) × ℕ := | |
| let l := D.left.countedArray D.acceptLeft | |
| let r := D.right.countedArray D.acceptRight | |
| let s := ResidueSort.counted r.1 D.wl D.lowModulus D.modulus | |
| ((l.1, s.1), l.2 + r.2 + s.2) | |
| theorem countedArrays_value : D.countedArrays.1 = (D.leftArray, D.storedRight) := by | |
| simp only [countedArrays, RepresentationLeaf.countedArray_value, | |
| leftArray, rightArray, ResidueSort.counted_value, storedRight] | |
| theorem countedArrays_work (hR : D.right.occurrences.card ≤ 2 ^ n) : | |
| D.countedArrays.2 ≤ | |
| 160 * (n + 1) ^ 2 * (D.left.occurrences.card + D.right.occurrences.card + 1) := by | |
| have hl := D.left.countedArray_work D.acceptLeft | |
| have hr := D.right.countedArray_work D.acceptRight | |
| have hs := D.counted_sort_work (D.rightArray_size_le.trans hR) | |
| have hp : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| have hn : 6 * n + 1 ≤ 7 * (n + 1) ^ 2 := by nlinarith | |
| have hm := Nat.mul_le_mul_right D.right.occurrences.card hn | |
| unfold countedArrays | |
| dsimp only | |
| rw [RepresentationLeaf.countedArray_value] | |
| change _ + _ + (ResidueSort.counted D.rightArray D.wl D.lowModulus D.modulus).2 ≤ _ | |
| nlinarith only [hl, hr, hs, hm, hp] | |
| end RepresentationPairData | |
| namespace RepresentationSetup | |
| variable {n : ℕ} (R : RepresentationSetup n) | |
| theorem rawLeaf_capacity (z : Layout n) (g : Guesses n) (f : R.Partitions z) | |
| (hn : 10000 ≤ n) | |
| (hlog : Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 ≤ (n : ℝ) / 1000) | |
| (hscale : Real.logb 2 (inputScale R.input : ℝ) ≤ (n : ℝ) / 1000000000) | |
| (j : Fin 2) (i : Fin 4) : | |
| (R.rawLeaf z g f (R.allocatedBackground z g hn hlog) j i).occurrences.card ≤ | |
| compressionDictionaryCapacity n := by | |
| exact_mod_cast (R.rawLeaf_main_card z g f hn hlog hscale j i).trans | |
| (main_leaf_rate_le_capacity hn) | |
| /-- Every residue, prefix, and sampler outcome uses the same setup bound. | |
| The statement includes unsuccessful and overflowing tasks. -/ | |
| theorem schedule_pair_setup_work (h : R.PrimeHistory) (r : R.Residues h.2) | |
| (hn : 10000 ≤ n) | |
| (hlog : Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 ≤ (n : ℝ) / 1000) | |
| (hscale : Real.logb 2 (inputScale R.input : ℝ) ≤ (n : ℝ) / 1000000000) | |
| (q : ℕ) (hq : 0 < q) (z : ℕ) (side : Fin 2) (P : MaskRestriction n) (child : Fin 2) : | |
| let D := ({ (R.scheduleData h r hn hlog q hq).parentData side z with maskRestriction := P }).pair child | |
| D.countedArrays.2 ≤ inputScale R.input ^ 3 * (compressionDictionaryCapacity n + 1) := by | |
| dsimp only | |
| let D := ({ (R.scheduleData h r hn hlog q hq).parentData side z with maskRestriction := P }).pair child | |
| let C := compressionDictionaryCapacity n | |
| let u := inputScale R.input | |
| have hl : D.left.occurrences.card ≤ C := | |
| R.rawLeaf_capacity h.1.1.1 h.1.1.2 h.1.2 hn hlog hscale side ⟨2 * child.val, by omega⟩ | |
| have hr : D.right.occurrences.card ≤ C := | |
| R.rawLeaf_capacity h.1.1.1 h.1.1.2 h.1.2 hn hlog hscale side ⟨2 * child.val + 1, by omega⟩ | |
| have hC : C ≤ 2 ^ n := by | |
| unfold C compressionDictionaryCapacity | |
| exact Nat.pow_le_pow_right (by decide) (by omega) | |
| have hw := D.countedArrays_work (hr.trans hC) | |
| have hs : D.left.occurrences.card + D.right.occurrences.card + 1 ≤ 2 * (C + 1) := by omega | |
| have h1 := Nat.mul_le_mul_left (160 * (n + 1) ^ 2) hs | |
| have hnu : n + 1 ≤ u := by unfold u inputScale; omega | |
| have hu : 10000 ≤ u := by omega | |
| have h2 : 320 * (n + 1) ^ 2 ≤ u ^ 3 := by | |
| have hsq := Nat.pow_le_pow_left hnu 2 | |
| have hm := Nat.mul_le_mul_right (u ^ 2) (show 320 ≤ u by omega) | |
| nlinarith only [hsq, hm] | |
| have h3 := Nat.mul_le_mul_right (C + 1) h2 | |
| change D.countedArrays.2 ≤ u ^ 3 * (C + 1) | |
| nlinarith only [hw, h1, h3] | |
| end RepresentationSetup | |
| end LowSpaceSubsetSum | |
| end OAI | |