openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionPreparationLedger.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.BudgetedCompressionSchedule | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionPassLedger | |
| namespace OAI | |
| /-! # Paying for every compression reader initialization | |
| The arrays have nonempty factors, so their lengths are bounded by the | |
| corresponding stream lengths. The stream-regeneration exponent margins therefore also bound | |
| initialization at every residue. | |
| -/ | |
| namespace LowSpaceSubsetSum.CompressionData | |
| open scoped BigOperators | |
| variable {n : ℕ} (D : CompressionData n) | |
| theorem stored_lengths_positive (e : Equiv.Perm (Fin n)) (i : Fin 4) : | |
| 0 < (D.storedFirst e i).length ∧ 0 < (D.storedSecond e i).length := by | |
| have hc (j : Fin 7) : 0 < (compactWeightList D.weights (D.block e j)).length := by | |
| rw [compactWeightList_length] | |
| exact Finset.card_pos.mpr ⟨0, zero_mem_distinctSums _ _⟩ | |
| have hl : 0 < (rawWeightList D.weights (D.leftRaw e)).length := by | |
| rw [rawWeightList_length] | |
| positivity | |
| have hr (j : Fin 2) : 0 < (rawWeightList D.weights (D.rightRaw e j)).length := by | |
| rw [rawWeightList_length] | |
| positivity | |
| fin_cases i | |
| · exact ⟨hc 4, hc 5⟩ | |
| · exact ⟨hc 6, hl⟩ | |
| · refine ⟨hc 0, ?_⟩ | |
| change 0 < (pairSumList (compactWeightList D.weights (D.block e 1)) | |
| (rawWeightList D.weights (D.rightRaw e 0))).length | |
| rw [pairSumList_length] | |
| exact Nat.mul_pos (hc 1) (hr 0) | |
| · refine ⟨hc 2, ?_⟩ | |
| change 0 < (pairSumList (compactWeightList D.weights (D.block e 3)) | |
| (rawWeightList D.weights (D.rightRaw e 1))).length | |
| rw [pairSumList_length] | |
| exact Nat.mul_pos (hc 3) (hr 1) | |
| theorem preparation_size_le (e : Equiv.Perm (Fin n)) : | |
| PreparedCompressionPass.size (PreparedCompressionPass.source D e) ≤ | |
| 2 * (∑ i : Fin 4, D.streamLength e i) + 1 := by | |
| have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) => show | |
| (D.storedFirst e i).length + (D.storedSecond e i).length ≤ 2 * D.streamLength e i from by | |
| have hp := D.stored_lengths_positive e i | |
| have h₁ := Nat.le_mul_of_pos_right (D.storedFirst e i).length hp.2 | |
| have h₂ := Nat.le_mul_of_pos_left (D.storedSecond e i).length hp.1 | |
| unfold streamLength | |
| omega) | |
| simpa only [PreparedCompressionPass.size, PreparedCompressionPass.source, | |
| List.size_toArray, ← Finset.mul_sum] using Nat.add_le_add_right hs 1 | |
| private theorem half_power_ceiling (n : ℕ) : | |
| (2 : ℝ) ^ ((n : ℝ) / 2) ≤ ((2 ^ ((n + 1) / 2) : ℕ) : ℝ) := by | |
| rw [Nat.cast_pow, Nat.cast_ofNat, ← Real.rpow_natCast] | |
| apply Real.rpow_le_rpow_of_exponent_le (by norm_num) | |
| have hh : (n : ℝ) ≤ 2 * (((n + 1) / 2 : ℕ) : ℝ) := by | |
| exact_mod_cast (show n ≤ 2 * ((n + 1) / 2) by omega) | |
| linarith | |
| theorem preparation_regeneration_bound (e : Equiv.Perm (Fin n)) | |
| (q : CompressionSetup.PrimeSpace n) (he : D.compactTests e = true) (hn : 10000 ≤ n) : | |
| q.val * PreparedCompressionPass.size (PreparedCompressionPass.source D e) ≤ | |
| 9 * 2 ^ ((n + 1) / 2) := by | |
| have hi (i : Fin 4) : q.val * D.streamLength e i ≤ 2 ^ ((n + 1) / 2) := by | |
| exact_mod_cast (D.prime_regeneration_bound e he (by omega) q i).trans (half_power_ceiling n) | |
| have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) => hi i) | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul, | |
| ← Finset.mul_sum] at hs | |
| have hq : q.val ≤ 2 ^ ((n + 1) / 2) := by | |
| apply (Nat.le_of_mem_primesLE (Finset.mem_filter.mp q.property).1).trans | |
| apply Nat.pow_le_pow_right (by decide) | |
| unfold compressionPrimeExponent | |
| omega | |
| have ha := Nat.mul_le_mul_left q.val (D.preparation_size_le e) | |
| nlinarith only [ha, hs, hq] | |
| theorem preparedSchedule_allowance (B : ℕ) (e : Equiv.Perm (Fin n)) | |
| (q : CompressionSetup.PrimeSpace n) (he : D.compactTests e = true) (hn : 10000 ≤ n) : | |
| BudgetedCompressionSchedule.allowance D.input (compressionDictionaryCapacity n) B | |
| (PreparedCompressionPass.source D e) q.val (primeRange_prime q.property).pos ≤ | |
| inputScale D.input ^ 7 * 2 ^ ((n + 1) / 2) := by | |
| rw [BudgetedCompressionSchedule.allowance_eq] | |
| simp only [BudgetedPreparedCompressionPass.allowance, PreparedCompressionPass.source_value, | |
| Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] | |
| have hp := D.preparation_regeneration_bound e q he hn | |
| have hj := D.sum_pass_allowance_scale B e q he hn | |
| have hq : q.val ≤ 2 ^ ((n + 1) / 2) := by | |
| apply (Nat.le_of_mem_primesLE (Finset.mem_filter.mp q.property).1).trans | |
| apply Nat.pow_le_pow_right (by decide) | |
| unfold compressionPrimeExponent | |
| omega | |
| have ht : 1 ≤ 2 ^ ((n + 1) / 2) := Nat.one_le_two_pow | |
| have hu : 10000 ≤ inputScale D.input := by unfold inputScale; omega | |
| have hu6 : 1 ≤ inputScale D.input ^ 6 := Nat.one_le_pow _ _ (by omega) | |
| have hm : 20 * inputScale D.input ^ 6 ≤ inputScale D.input ^ 7 := by | |
| calc | |
| _ ≤ inputScale D.input * inputScale D.input ^ 6 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := (pow_succ' _ _).symm | |
| have hprep := Nat.mul_le_mul_left (inputScale D.input ^ 6) hp | |
| have hfinal := Nat.mul_le_mul_right (2 ^ ((n + 1) / 2)) hm | |
| have hsmall := Nat.mul_le_mul_right (2 ^ ((n + 1) / 2)) hu6 | |
| unfold BudgetedPreparedCompressionPass.charge | |
| nlinarith only [hj, hprep, hfinal, hq, ht, hsmall] | |
| end LowSpaceSubsetSum.CompressionData | |
| end OAI | |