openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionArrayWork.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionArrayBuild | |
| namespace OAI | |
| /-! # Work of constructing the compression trial's shared arrays -/ | |
| namespace LowSpaceSubsetSum.CompressionArrayBuild | |
| open scoped BigOperators | |
| variable {n : ℕ} | |
| theorem source_lengths (D : CompressionData n) (e : Equiv.Perm (Fin n)) (hn : 10000 ≤ n) : | |
| (∀ i, ((source D e).compact i).length ≤ (n + 1) / 2) ∧ | |
| (source D e).left.length ≤ (n + 1) / 2 ∧ | |
| (∀ i, ((source D e).right i).length ≤ (n + 1) / 2) := by | |
| have hc (i : Fin 7) : ((source D e).compact i).length = compressionHalfSize n := by | |
| simp only [source, Finset.length_sort, CompressionData.block, permuteSubset, | |
| Finset.card_map, compressionBlock_card] | |
| simp only [source, Finset.length_sort, D.leftRaw_card, D.rightRaw_card] | |
| refine ⟨?_, ?_, ?_⟩ | |
| · intro i | |
| rw [show (D.block e i).card = compressionHalfSize n from by | |
| simpa only [source, Finset.length_sort] using hc i, compressionHalfSize_eq] | |
| omega | |
| · unfold compressionLeftRawSize compressionRightRawSize | |
| rw [compressionHalfSize_eq] | |
| omega | |
| · intro i | |
| unfold compressionRawHalfSize compressionRightRawSize | |
| split <;> omega | |
| theorem compact_work_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) | |
| (hn : 10000 ≤ n) : | |
| (∑ i : Fin 7, (compactLists D.weights (source D e))[i.val].2) ≤ | |
| 7 * inputScale D.input ^ 4 * 2 ^ ((n + 1) / 2) := by | |
| have hl := (source_lengths D e hn).1 | |
| have hb (i : Fin 7) : (compactLists D.weights (source D e))[i.val].2 ≤ | |
| inputScale D.input ^ 4 * 2 ^ ((n + 1) / 2) := by | |
| have hw := CompressionWeights.compact_scale D.input hn D.weights | |
| ((source D e).compact i) ((hl i).trans (by omega)) | |
| simpa only [compactLists, Vector.getElem_ofFn] using | |
| hw.trans (Nat.mul_le_mul_left _ (Nat.pow_le_pow_right (by decide) (hl i))) | |
| have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hb i) | |
| simpa only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul, Nat.mul_assoc] using hs | |
| theorem compact_lengths_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) | |
| (hn : 10000 ≤ n) : | |
| (∑ i : Fin 7, (compactLists D.weights (source D e))[i.val].1.length) ≤ | |
| 7 * 2 ^ ((n + 1) / 2) := by | |
| have hb (i : Fin 7) : (compactLists D.weights (source D e))[i.val].1.length ≤ | |
| 2 ^ ((n + 1) / 2) := by | |
| rw [compactLists_source] | |
| have hd := (List.dedup_sublist ((rawWeightList D.weights (D.block e i)).mergeSort | |
| (fun x y => decide (x ≤ y)))).length_le | |
| simp only [List.length_mergeSort, rawWeightList_length] at hd | |
| exact hd.trans (Nat.pow_le_pow_right (by decide) (by | |
| simpa only [source, Finset.length_sort] using (source_lengths D e hn).1 i)) | |
| simpa only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] using | |
| Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hb i) | |
| theorem raw_work_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) | |
| (hn : 10000 ≤ n) : | |
| (CompressionWeights.raw D.weights (source D e).left).2 + | |
| (CompressionWeights.raw D.weights ((source D e).right 0)).2 + | |
| (CompressionWeights.raw D.weights ((source D e).right 1)).2 ≤ | |
| 3 * inputScale D.input ^ 3 * 2 ^ ((n + 1) / 2) := by | |
| have hl := source_lengths D e hn | |
| have hs (V : List (Fin n)) (hv : V.length ≤ (n + 1) / 2) : | |
| (CompressionWeights.raw D.weights V).2 ≤ inputScale D.input ^ 3 * 2 ^ ((n + 1) / 2) := | |
| (CompressionWeights.raw_scale D.input hn D.weights V (hv.trans (by omega))).trans | |
| (Nat.mul_le_mul_left _ (Nat.pow_le_pow_right (by decide) hv)) | |
| have h₀ := hs _ hl.2.1 | |
| have h₁ := hs _ (hl.2.2 0) | |
| have h₂ := hs _ (hl.2.2 1) | |
| nlinarith only [h₀, h₁, h₂] | |
| theorem assemble_work_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) | |
| (he : D.compactTests e = true) (hn : 10000 ≤ n) : | |
| (assemble (compactLists D.weights (source D e)) | |
| (CompressionWeights.raw D.weights (source D e).left).1 | |
| (CompressionWeights.raw D.weights ((source D e).right 0)).1 | |
| (CompressionWeights.raw D.weights ((source D e).right 1)).1).2 ≤ | |
| 18 * 2 ^ ((n + 1) / 2) + 13 := by | |
| let T := 2 ^ ((n + 1) / 2) | |
| have hc : compressionDictionaryCapacity n ≤ T := by | |
| unfold compressionDictionaryCapacity T | |
| exact Nat.pow_le_pow_right (by decide) (by omega) | |
| have hs (i : Fin 4) := D.stored_lists_capacity e he (by omega) i | |
| have hf (i : Fin 4) := (hs i).1.trans hc | |
| have hr (i : Fin 4) := (hs i).2.trans hc | |
| have ha : PreparedCompressionPass.size (PreparedCompressionPass.source D e) ≤ 8 * T + 1 := by | |
| have hb := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) => | |
| show (D.storedFirst e i).length + (D.storedSecond e i).length ≤ 2 * T from by | |
| have := hf i | |
| have := hr i | |
| omega) | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hb | |
| simp only [PreparedCompressionPass.size, PreparedCompressionPass.source, List.size_toArray] | |
| omega | |
| have hp (i : Fin 2) : 0 < (rawWeightList D.weights (D.rightRaw e i)).length := by | |
| rw [rawWeightList_length] | |
| positivity | |
| have h₀ := pairSums_work_le (compactWeightList D.weights (D.block e 1)) | |
| (rawWeightList D.weights (D.rightRaw e 0)) (hp 0) | |
| have h₁ := pairSums_work_le (compactWeightList D.weights (D.block e 3)) | |
| (rawWeightList D.weights (D.rightRaw e 1)) (hp 1) | |
| have hb₀ : (pairSums (compactWeightList D.weights (D.block e 1)) | |
| (rawWeightList D.weights (D.rightRaw e 0))).2 ≤ 5 * T + 1 := | |
| h₀.trans (Nat.add_le_add_right (Nat.mul_le_mul_left 5 (hr 2)) 1) | |
| have hb₁ : (pairSums (compactWeightList D.weights (D.block e 3)) | |
| (rawWeightList D.weights (D.rightRaw e 1))).2 ≤ 5 * T + 1 := | |
| h₁.trans (Nat.add_le_add_right (Nat.mul_le_mul_left 5 (hr 3)) 1) | |
| change _ + _ + PreparedCompressionPass.size (assemble _ _ _ _).1 + 10 ≤ _ | |
| rw [assemble_source] | |
| simp only [compactLists, Vector.getElem_ofFn, source, CompressionWeights.compact_source, | |
| CompressionWeights.raw_source] | |
| change (pairSums (compactWeightList D.weights (D.block e 1)) | |
| (rawWeightList D.weights (D.rightRaw e 0))).2 + | |
| (pairSums (compactWeightList D.weights (D.block e 3)) | |
| (rawWeightList D.weights (D.rightRaw e 1))).2 + | |
| PreparedCompressionPass.size (PreparedCompressionPass.source D e) + 10 ≤ 18 * T + 13 | |
| omega | |
| theorem run_work_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) | |
| (hn : 10000 ≤ n) : | |
| (run D.weights (source D e) (2 ^ CompressionSetup.executableCapExponent n)).2 ≤ | |
| inputScale D.input ^ 5 * 2 ^ ((n + 1) / 2) := by | |
| have hc := compact_work_source D e hn | |
| have hlen := compact_lengths_source D e hn | |
| have hr := raw_work_source D e hn | |
| have hu : 10000 ≤ inputScale D.input := by unfold inputScale; omega | |
| have hp34 : inputScale D.input ^ 3 ≤ inputScale D.input ^ 4 := | |
| pow_le_pow_right' (by omega) (by decide) | |
| have hp4 : 1 ≤ inputScale D.input ^ 4 := Nat.one_le_pow _ _ (by omega) | |
| have hm : 100 * inputScale D.input ^ 4 ≤ inputScale D.input ^ 5 := by | |
| calc | |
| _ ≤ inputScale D.input * inputScale D.input ^ 4 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := (pow_succ' _ _).symm | |
| have hT : 1 ≤ 2 ^ ((n + 1) / 2) := Nat.one_le_two_pow | |
| have hsmall := Nat.mul_le_mul_right (2 ^ ((n + 1) / 2)) hp4 | |
| have h34 := Nat.mul_le_mul_right (2 ^ ((n + 1) / 2)) hp34 | |
| have hfinal := Nat.mul_le_mul_right (2 ^ ((n + 1) / 2)) hm | |
| dsimp only [run] | |
| rw [passed_source] | |
| simp only [Finset.sum_add_distrib] | |
| split | |
| next he => | |
| have ha := assemble_work_source D e he hn | |
| dsimp only | |
| nlinarith only [hc, hlen, hr, ha, hT, hsmall, h34, hfinal] | |
| next => | |
| dsimp only | |
| nlinarith only [hc, hlen, hT, hsmall, hfinal] | |
| end LowSpaceSubsetSum.CompressionArrayBuild | |
| end OAI | |