openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionWeights.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedSubsets | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedWeights | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedDedup | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredSort | |
| namespace OAI | |
| /-! # Executing raw and compact subset-weight generation | |
| Indices are supplied in canonical input order. The raw generator constructs | |
| the same sublists as the source program; every weight is evaluated by the | |
| measured integer routine. Mapping uses an accumulator and one final reversal. | |
| -/ | |
| namespace LowSpaceSubsetSum.CompressionWeights | |
| variable {n : ℕ} | |
| def weightsAcc (a : Fin n → ℤ) : List (List (Fin n)) → List ℤ → ℕ → List ℤ × ℕ | |
| | [], acc, work => (acc.reverse, work + acc.length + 1) | |
| | xs :: rest, acc, work => | |
| let w := CountedWeights.weight a xs | |
| weightsAcc a rest (w.1 :: acc) (work + w.2 + 2) | |
| theorem weightsAcc_value (a : Fin n → ℤ) (xs : List (List (Fin n))) | |
| (acc : List ℤ) (work : ℕ) : | |
| (weightsAcc a xs acc work).1 = acc.reverse ++ xs.map (fun x => weight a x.toFinset) := by | |
| induction xs generalizing acc work with | |
| | nil => simp only [weightsAcc, List.map_nil, List.append_nil] | |
| | cons x xs ih => | |
| simp only [weightsAcc, ih, List.reverse_cons, CountedWeights.weight_value, | |
| List.map_cons, List.append_assoc, List.singleton_append] | |
| theorem weightsAcc_work (a : Fin n → ℤ) (xs : List (List (Fin n))) | |
| (acc : List ℤ) (work K : ℕ) (hk : ∀ x ∈ xs, (CountedWeights.weight a x).2 ≤ K) : | |
| (weightsAcc a xs acc work).2 ≤ work + (K + 3) * xs.length + acc.length + 1 := by | |
| induction xs generalizing acc work with | |
| | nil => simp only [weightsAcc, List.length_nil, Nat.mul_zero, Nat.add_zero]; rfl | |
| | cons x xs ih => | |
| have hx := hk x (by simp) | |
| have ht := ih ((CountedWeights.weight a x).1 :: acc) | |
| (work + (CountedWeights.weight a x).2 + 2) (fun y hy => hk y (by simp [hy])) | |
| simp only [List.length_cons] at ht | |
| simp only [weightsAcc, List.length_cons, Nat.mul_add, Nat.mul_one] | |
| omega | |
| def raw (a : Fin n → ℤ) (indices : List (Fin n)) : List ℤ × ℕ := | |
| let masks := CountedSubsets.all indices | |
| let out := weightsAcc a masks.1 [] 0 | |
| (out.1, masks.2 + out.2 + 1) | |
| theorem raw_value (a : Fin n → ℤ) (indices : List (Fin n)) : | |
| (raw a indices).1 = indices.sublists.map (fun x => weight a x.toFinset) := by | |
| simp only [raw, weightsAcc_value, List.reverse_nil, List.nil_append, CountedSubsets.all_value] | |
| theorem raw_source (a : Fin n → ℤ) (V : Finset (Fin n)) : | |
| (raw a (V.sort (· ≤ ·))).1 = rawWeightList a V := raw_value _ _ | |
| theorem raw_length (a : Fin n → ℤ) (indices : List (Fin n)) : | |
| (raw a indices).1.length = 2 ^ indices.length := by | |
| simp only [raw_value, List.length_map, List.length_sublists] | |
| theorem raw_work (a : Fin n → ℤ) (indices : List (Fin n)) (hlen : indices.length ≤ n) : | |
| (raw a indices).2 ≤ ((n + 4) * n + 8) * 2 ^ indices.length + 2 := by | |
| have hw := weightsAcc_work a (CountedSubsets.all indices).1 [] 0 ((n + 4) * n + 1) (by | |
| intro xs hx | |
| have hsub : xs.Sublist indices := by | |
| rw [CountedSubsets.all_value] at hx | |
| exact List.mem_sublists.mp hx | |
| have hl : xs.length ≤ n := hsub.length_le.trans hlen | |
| exact (CountedWeights.weight_work a xs).trans (by gcongr)) | |
| have he := CountedSubsets.all_work indices | |
| simp only [List.length_nil, Nat.zero_add, Nat.add_zero, CountedSubsets.all_length] at hw | |
| change _ + _ + 1 ≤ _ | |
| nlinarith only [hw, he] | |
| theorem raw_scale (I : Instance n) (hn : 10000 ≤ n) (a : Fin n → ℤ) | |
| (indices : List (Fin n)) (hlen : indices.length ≤ n) : | |
| (raw a indices).2 ≤ inputScale I ^ 3 * 2 ^ indices.length := by | |
| have hw := raw_work a indices hlen | |
| have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega | |
| have hu' : 10000 ≤ inputScale I := by omega | |
| have hp : ((n + 4) * n + 10) ≤ inputScale I ^ 3 := by | |
| have hs : (n + 4) * n ≤ 4 * inputScale I ^ 2 := by nlinarith only [hu, hn] | |
| have h1 : 1 ≤ inputScale I ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| have hm : 14 * inputScale I ^ 2 ≤ inputScale I ^ 3 := by | |
| calc | |
| _ ≤ inputScale I * inputScale I ^ 2 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := (pow_succ' _ _).symm | |
| omega | |
| have hsize : 1 ≤ 2 ^ indices.length := Nat.one_le_two_pow | |
| have hm := Nat.mul_le_mul_right (2 ^ indices.length) hp | |
| nlinarith only [hw, hsize, hm] | |
| def compact (a : Fin n → ℤ) (indices : List (Fin n)) : List ℤ × ℕ := | |
| let initial := raw a indices | |
| let sorted := MeasuredSort.sort (fun x y : ℤ => (decide (x ≤ y), 1)) initial.1 | |
| let out := CountedDedup.run sorted.1 | |
| (out.1, initial.2 + sorted.2 + out.2 + 1) | |
| theorem compact_source (a : Fin n → ℤ) (V : Finset (Fin n)) : | |
| (compact a (V.sort (· ≤ ·))).1 = compactWeightList a V := by | |
| have h := CompactWeightWork.run_value a V | |
| simpa only [compact, raw_source, MeasuredSort.sort_value, CompactWeightWork.run, | |
| CountedSort.sort_value] using h | |
| theorem compact_scale (I : Instance n) (hn : 10000 ≤ n) (a : Fin n → ℤ) | |
| (indices : List (Fin n)) (hlen : indices.length ≤ n) : | |
| (compact a indices).2 ≤ inputScale I ^ 4 * 2 ^ indices.length := by | |
| have hr := raw_scale I hn a indices hlen | |
| have hs := MeasuredSort.sort_work (fun x y : ℤ => (decide (x ≤ y), 1)) 1 | |
| (fun _ _ => le_rfl) (raw a indices).1 n | |
| (by rw [raw_length]; exact Nat.pow_le_pow_right (by decide) hlen) | |
| have hd := CountedDedup.run_work | |
| (MeasuredSort.sort (fun x y : ℤ => (decide (x ≤ y), 1)) (raw a indices).1).1 | |
| simp only [MeasuredSort.sort_value, List.length_mergeSort, raw_length] at hs hd | |
| have hu : n ≤ inputScale I := by unfold inputScale; omega | |
| have hu' : 10000 ≤ inputScale I := hn.trans hu | |
| have hu3 : inputScale I ≤ inputScale I ^ 3 := by | |
| simpa only [pow_one] using | |
| (pow_le_pow_right' (by omega : 1 ≤ inputScale I) (by decide : 1 ≤ 3)) | |
| have h1 : 1 ≤ inputScale I ^ 3 := Nat.one_le_pow _ _ (by omega) | |
| have hc : inputScale I ^ 3 + 12 * n + 7 ≤ inputScale I ^ 4 := by | |
| have hm : 20 * inputScale I ^ 3 ≤ inputScale I ^ 4 := by | |
| calc | |
| _ ≤ inputScale I * inputScale I ^ 3 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := (pow_succ' _ _).symm | |
| omega | |
| have hsize : 1 ≤ 2 ^ indices.length := Nat.one_le_two_pow | |
| have hm := Nat.mul_le_mul_right (2 ^ indices.length) hc | |
| change _ + _ + _ + 1 ≤ _ | |
| simp only [MeasuredSort.sort_value] | |
| nlinarith only [hr, hs, hd, hsize, hm] | |
| end LowSpaceSubsetSum.CompressionWeights | |
| end OAI | |