openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionWeightCells.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MixerWeightCells | |
| namespace OAI | |
| /-! # Live storage of compression's compact weight lists | |
| Raw subset masks and their weights use the concrete list generator. The | |
| sorted list is compacted by adjacent comparisons, retaining its existing | |
| linear work counter and accounting for each recursive return frame. | |
| -/ | |
| namespace LowSpaceSubsetSum.CompressionWeightCells | |
| variable {n : ℕ} | |
| def tail (previous : ℤ) : List ℤ → (List ℤ × ℕ) × ℕ | |
| | [] => (([previous], 1), 4) | |
| | x :: xs => | |
| if previous = x then | |
| let rest := tail previous xs | |
| ((rest.1.1, rest.1.2+1), rest.2+2) | |
| else | |
| let rest := tail x xs | |
| ((previous::rest.1.1, rest.1.2+1), rest.2+4) | |
| theorem tail_value (previous : ℤ) (xs : List ℤ) : | |
| (tail previous xs).1 = CountedDedup.tail previous xs := by | |
| induction xs generalizing previous with | |
| | nil => rfl | |
| | cons x xs ih => | |
| simp only [tail, CountedDedup.tail] | |
| split <;> simp only [ih] | |
| theorem tail_cells (previous : ℤ) (xs : List ℤ) : | |
| (tail previous xs).2 ≤ 4*xs.length+4 := by | |
| induction xs generalizing previous with | |
| | nil => exact le_rfl | |
| | cons x xs ih => | |
| have h₁ := ih previous | |
| have h₂ := ih x | |
| simp only [tail, List.length_cons] | |
| split <;> dsimp only <;> omega | |
| def dedup : List ℤ → (List ℤ × ℕ) × ℕ | |
| | [] => (([], 1), 4) | |
| | x :: xs => tail x xs | |
| theorem dedup_value (xs : List ℤ) : (dedup xs).1 = CountedDedup.run xs := by | |
| cases xs with | |
| | nil => rfl | |
| | cons x xs => exact tail_value x xs | |
| theorem dedup_cells (xs : List ℤ) : (dedup xs).2 ≤ 4*xs.length+4 := by | |
| cases xs with | |
| | nil => exact le_rfl | |
| | cons x xs => | |
| have h := tail_cells x xs | |
| simp only [dedup, List.length_cons] | |
| omega | |
| def compact (a : Fin n → ℤ) (indices : List (Fin n)) : (List ℤ × ℕ) × ℕ := | |
| let initial := MixerWeightCells.raw a indices | |
| let sorted := MeasuredSortCells.run 1 MixerWeightCells.compare | |
| (Nat.clog 2 initial.1.1.length) initial.1.1 | |
| let out := dedup sorted.1.1 | |
| ((out.1.1, initial.1.2+sorted.1.2+out.1.2+1), | |
| initial.2+sorted.2+out.2+4*(initial.1.1.length+1)+32) | |
| theorem compact_value (a : Fin n → ℤ) (indices : List (Fin n)) : | |
| (compact a indices).1 = CompressionWeights.compact a indices := by | |
| simp only [compact, MixerWeightCells.raw_value, MeasuredSortCells.run_value, | |
| dedup_value, CompressionWeights.compact, MeasuredSort.sort, MixerWeightCells.compare] | |
| theorem compact_cells (a : Fin n → ℤ) (indices : List (Fin n)) | |
| (hi : indices.length ≤ n) : | |
| (compact a indices).2 ≤ 512*(n+2)^2*(2^indices.length+1) := by | |
| have hr := MixerWeightCells.raw_cells a indices hi | |
| have hl : (MixerWeightCells.raw a indices).1.1.length = 2^indices.length := by | |
| rw [MixerWeightCells.raw_value, CompressionWeights.raw_length] | |
| have hs := MeasuredSortCells.run_cells 1 MixerWeightCells.compare 4 (fun _ _ => le_rfl) | |
| (Nat.clog 2 (MixerWeightCells.raw a indices).1.1.length) | |
| (MixerWeightCells.raw a indices).1.1 | |
| have hd := dedup_cells (MeasuredSortCells.run 1 MixerWeightCells.compare | |
| (Nat.clog 2 (MixerWeightCells.raw a indices).1.1.length) | |
| (MixerWeightCells.raw a indices).1.1).1.1 | |
| rw [MeasuredSortCells.run_length, hl] at hd | |
| simp only [hl, Nat.clog_pow 2 _ (by decide)] at hs | |
| have hs' := hs.trans (Nat.mul_le_mul (show indices.length+1 ≤ n+2 by omega) | |
| (show 24*(1+2)*(2^indices.length+1)+4 ≤ 76*(2^indices.length+1) by omega)) | |
| have hsmall : 4*(2^indices.length+1)+32 ≤ 20*(n+2)*(2^indices.length+1) := by | |
| have hN : 1 ≤ 2^indices.length := Nat.one_le_two_pow | |
| nlinarith only [hN] | |
| have hdegree : n+2 ≤ (n+2)^2 := by nlinarith | |
| have hfinal := Nat.mul_le_mul_right (2^indices.length+1) hdegree | |
| change _+_+_+4*((MixerWeightCells.raw a indices).1.1.length+1)+32 ≤ _ | |
| rw [hl] | |
| simp only [Nat.clog_pow 2 _ (by decide)] at hd ⊢ | |
| simp only [Nat.mul_assoc] at hr hs' hsmall hfinal ⊢ | |
| nlinarith only [hr, hs', hd, hsmall, hfinal] | |
| end LowSpaceSubsetSum.CompressionWeightCells | |
| end OAI | |