openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /SeparatorParameterExecution.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorParameters | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedBinomial | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredLog2 | |
| namespace OAI | |
| /-! # Integer execution of the separator sizes and sample counts | |
| A constant-state power loop and binary-log loop compute the prescribed | |
| sample size. Five multiplicative binomial loops and four integer ceiling | |
| divisions compute the actual family-array lengths. | |
| -/ | |
| namespace LowSpaceSubsetSum.SeparatorParameterExecution | |
| open scoped BigOperators | |
| def powerLoop : ℕ → ℕ → ℕ → ℕ × ℕ | |
| | 0, value, work => (value, work + 1) | |
| | fuel + 1, value, work => powerLoop fuel (value * 3) (work + 3) | |
| theorem powerLoop_formula (fuel value work : ℕ) : | |
| powerLoop fuel value work = (value * 3 ^ fuel, work + 3 * fuel + 1) := by | |
| induction fuel generalizing value work with | |
| | zero => simp [powerLoop] | |
| | succ fuel ih => | |
| simp only [powerLoop, ih, pow_succ] | |
| congr 1 <;> ring | |
| theorem three_power_bound (m : ℕ) : 3 ^ m ≤ 2 ^ (2 * m) := by | |
| calc | |
| 3 ^ m ≤ 4 ^ m := Nat.pow_le_pow_left (by decide) m | |
| _ = 2 ^ (2 * m) := by rw [pow_mul]; rfl | |
| def logBits (m : ℕ) : ℕ × ℕ := | |
| let power := powerLoop m 1 0 | |
| let bits := MeasuredLog2.run (2 * m) power.1 | |
| (bits.1, power.2 + bits.2 + 2) | |
| theorem logBits_value (m : ℕ) : (logBits m).1 = SeparatorParameters.logBits m := by | |
| simp only [logBits, powerLoop_formula, one_mul] | |
| rw [MeasuredLog2.run_value _ _ (three_power_bound m), Nat.log2_eq_log_two] | |
| rfl | |
| theorem logBits_work (m : ℕ) : (logBits m).2 ≤ 9 * m + 4 := by | |
| have h := MeasuredLog2.run_work (2 * m) (3 ^ m) | |
| simp only [logBits, powerLoop_formula, one_mul, zero_add] | |
| omega | |
| def sample (g k : ℕ) : ℕ × ℕ := | |
| let bits := logBits (4 * g) | |
| ((8 * g * g - bits.1 * (g - k)) / (16 * g), bits.2 + 12) | |
| theorem sample_value (g k : ℕ) : (sample g k).1 = SeparatorParameters.sampleSize g k := by | |
| simp only [sample, logBits_value, SeparatorParameters.sampleSize] | |
| theorem sample_work (g k : ℕ) : (sample g k).2 ≤ 36 * g + 16 := by | |
| have h := logBits_work (4 * g) | |
| change _ + 12 ≤ _ | |
| omega | |
| def families (g k e : ℕ) : Vector ℕ 4 × ℕ := | |
| let numerator := CountedBinomial.run g e | |
| let denominators := Vector.ofFn (fun i : Fin 4 => | |
| CountedBinomial.run (g / 2) (e - balancedBlockCounts 4 k i)) | |
| (Vector.ofFn (fun i : Fin 4 => (10 * numerator.value) ⌈/⌉ denominators[i.val].value), | |
| 8 * numerator.steps + (∑ i : Fin 4, 8 * denominators[i.val].steps + 6) + 10) | |
| theorem families_value (g k e : ℕ) (i : Fin 4) : | |
| (families g k e).1[i.val] = | |
| (10 * g.choose e) ⌈/⌉ (g / 2).choose (e - balancedBlockCounts 4 k i) := by | |
| simp only [families, Vector.getElem_ofFn, CountedBinomial.run_value] | |
| theorem families_work (g k e : ℕ) : (families g k e).2 ≤ 24 * g + 34 := by | |
| have hn := CountedBinomial.run_steps g e | |
| have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) => | |
| Nat.mul_le_mul_left 8 | |
| (CountedBinomial.run_steps (g / 2) (e - balancedBlockCounts 4 k i))) | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hs | |
| have hd : 2 * (g / 2) ≤ g := by omega | |
| change 8 * (CountedBinomial.run g e).steps + | |
| (∑ i : Fin 4, 8 * (CountedBinomial.run (g / 2) (e - balancedBlockCounts 4 k i)).steps + 6) + 10 ≤ _ | |
| omega | |
| structure Data where | |
| size : ℕ | |
| counts : Vector ℕ 4 | |
| def run (g k : ℕ) : Data × ℕ := | |
| let e := sample g k | |
| let counts := families g k e.1 | |
| (⟨e.1, counts.1⟩, e.2 + counts.2 + 1) | |
| theorem size_value (g k : ℕ) : (run g k).1.size = SeparatorParameters.sampleSize g k := | |
| sample_value g k | |
| theorem counts_value (g k : ℕ) (i : Fin 4) : | |
| (run g k).1.counts[i.val] = SeparatorParameters.familyCount g k i := by | |
| simp only [run, sample_value, families_value, SeparatorParameters.familyCount] | |
| theorem work (g k : ℕ) : (run g k).2 ≤ 60 * g + 51 := by | |
| have he := sample_work g k | |
| have hc := families_work g k (sample g k).1 | |
| change _ + _ + 1 ≤ _ | |
| omega | |
| theorem rounded_size (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g) | |
| (hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) (i : Fin 4) : | |
| (run g k).1.size = (SeparatorParameters.rounded g k hg heven hk hklo).e i := | |
| size_value g k | |
| theorem rounded_counts (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g) | |
| (hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) (i : Fin 4) : | |
| (run g k).1.counts[i.val] = (SeparatorParameters.rounded g k hg heven hk hklo).counts i := by | |
| rw [counts_value, SeparatorParameters.familyCount_eq g k hg heven hk hklo] | |
| end LowSpaceSubsetSum.SeparatorParameterExecution | |
| end OAI | |