openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /SeparatorParameters.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorWorkBound | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationLeafDomains | |
| import Mathlib.Algebra.Order.Floor.Div | |
| namespace OAI | |
| /-! # Exact integer construction of the separator sample size | |
| The logarithm floor is the binary bit count of `3^(4g)`. The subsequent | |
| floor is a natural-number division. Neither operation uses real arithmetic. | |
| -/ | |
| namespace LowSpaceSubsetSum.SeparatorParameters | |
| def logBits (m : ℕ) : ℕ := Nat.log 2 (3 ^ m) | |
| def sampleSize (g k : ℕ) : ℕ := | |
| (8 * g * g - logBits (4 * g) * (g - k)) / (16 * g) | |
| def familyCount (g k : ℕ) (i : Fin 4) : ℕ := | |
| (10 * g.choose (sampleSize g k)) ⌈/⌉ | |
| (g / 2).choose (sampleSize g k - balancedBlockCounts 4 k i) | |
| noncomputable def rationalBias (g k : ℕ) : ℝ := | |
| (g : ℝ) / 2 - (logBits (4 * g) : ℝ) * ((g : ℝ) - k) / (16 * g) | |
| theorem logBits_bounds (m : ℕ) : | |
| (logBits m : ℝ) ≤ (m : ℝ) * separatorAlpha ∧ | |
| (m : ℝ) * separatorAlpha < (logBits m : ℝ) + 1 := by | |
| have hlog : Real.logb 2 ((3 ^ m : ℕ) : ℝ) = (m : ℝ) * separatorAlpha := by | |
| push_cast | |
| rw [Real.logb_pow] | |
| rfl | |
| have hfloor : ⌊(m : ℝ) * separatorAlpha⌋₊ = logBits m := by | |
| rw [← hlog] | |
| exact Real.natFloor_logb_natCast 2 (3 ^ m) | |
| have hnonneg : 0 ≤ (m : ℝ) * separatorAlpha := by | |
| exact mul_nonneg (Nat.cast_nonneg _) (le_of_lt (lt_trans (by norm_num) separatorAlpha_bounds.1)) | |
| constructor | |
| · rw [← hfloor] | |
| exact Nat.floor_le hnonneg | |
| · rw [← hfloor] | |
| exact Nat.lt_floor_add_one _ | |
| theorem logBits_le (g : ℕ) : logBits (4 * g) ≤ 8 * g := by | |
| have h := (logBits_bounds (4 * g)).1 | |
| have hmul := mul_le_mul_of_nonneg_left separatorAlpha_bounds.2.le | |
| (show (0 : ℝ) ≤ 4 * g by positivity) | |
| have hR : (logBits (4 * g) : ℝ) ≤ (8 * g : ℕ) := by | |
| push_cast at h ⊢ | |
| nlinarith | |
| exact_mod_cast hR | |
| theorem numerator_nonnegative (g k : ℕ) : | |
| logBits (4 * g) * (g - k) ≤ 8 * g * g := | |
| Nat.mul_le_mul (logBits_le g) (Nat.sub_le g k) | |
| theorem sampleSize_eq_floor (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) : | |
| sampleSize g k = ⌊rationalBias g k⌋₊ := by | |
| have hgR : (g : ℝ) ≠ 0 := by exact_mod_cast hg.ne' | |
| have he : rationalBias g k = | |
| ((8 * g * g - logBits (4 * g) * (g - k) : ℕ) : ℝ) / (16 * g : ℕ) := by | |
| rw [Nat.cast_sub (numerator_nonnegative g k)] | |
| simp only [Nat.cast_mul, Nat.cast_ofNat, Nat.cast_sub hk] | |
| unfold rationalBias | |
| field_simp [hgR] | |
| ring | |
| rw [he, Nat.floor_div_eq_div] | |
| rfl | |
| theorem rationalBias_bounds (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) | |
| (hklo : 2 * g ≤ 3 * k) : | |
| (g : ℝ) / 3 ≤ rationalBias g k ∧ rationalBias g k ≤ (g : ℝ) / 2 := by | |
| have hgR : (0 : ℝ) < g := by exact_mod_cast hg | |
| have hkR : (k : ℝ) ≤ g := by exact_mod_cast hk | |
| have hkloR : (2 : ℝ) * g ≤ 3 * k := by exact_mod_cast hklo | |
| have hbits : (logBits (4 * g) : ℝ) ≤ 8 * g := by exact_mod_cast logBits_le g | |
| have hprod := mul_le_mul_of_nonneg_right hbits (sub_nonneg.mpr hkR) | |
| have hsub : 0 ≤ (logBits (4 * g) : ℝ) * ((g : ℝ) - k) / (16 * g) := by positivity | |
| unfold rationalBias | |
| constructor | |
| · apply (le_sub_iff_add_le).mpr | |
| have hdiv : (logBits (4 * g) : ℝ) * ((g : ℝ) - k) / (16 * g) ≤ (g : ℝ) / 6 := by | |
| apply (div_le_iff₀ (by positivity)).mpr | |
| nlinarith | |
| linarith | |
| · linarith | |
| theorem sampleSize_error (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) | |
| (hklo : 2 * g ≤ 3 * k) : | |
| |(sampleSize g k : ℝ) - rationalBias g k| ≤ 1 := by | |
| rw [sampleSize_eq_floor g k hg hk] | |
| have hn := (rationalBias_bounds g k hg hk hklo).1 | |
| have hnonneg : 0 ≤ rationalBias g k := le_trans (by positivity) hn | |
| exact abs_le.mpr ⟨by linarith [Nat.lt_floor_add_one (rationalBias g k)], | |
| by linarith [Nat.floor_le hnonneg]⟩ | |
| theorem rationalBias_error (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) : | |
| |rationalBias g k - (g : ℝ) * | |
| ((k : ℝ) / (4 * g) + separatorY ((k : ℝ) / (4 * g)))| ≤ 1 := by | |
| have hgR : (0 : ℝ) < g := by exact_mod_cast hg | |
| have hkR : (k : ℝ) ≤ g := by exact_mod_cast hk | |
| have hlo := (logBits_bounds (4 * g)).1 | |
| have hhi := (logBits_bounds (4 * g)).2 | |
| push_cast at hlo hhi | |
| have hgap0 : 0 ≤ 4 * (g : ℝ) * separatorAlpha - logBits (4 * g) := by linarith | |
| have hgap1 : 4 * (g : ℝ) * separatorAlpha - logBits (4 * g) ≤ 1 := by linarith | |
| have hprod := mul_le_mul_of_nonneg_right hgap1 (sub_nonneg.mpr hkR) | |
| have he : rationalBias g k - (g : ℝ) * | |
| ((k : ℝ) / (4 * g) + separatorY ((k : ℝ) / (4 * g))) = | |
| (4 * (g : ℝ) * separatorAlpha - logBits (4 * g)) * ((g : ℝ) - k) / (16 * g) := by | |
| unfold rationalBias separatorY | |
| field_simp [hgR.ne'] | |
| ring | |
| rw [he, abs_of_nonneg (by positivity)] | |
| apply (div_le_iff₀ (by positivity)).mpr | |
| nlinarith [show (0 : ℝ) ≤ k from Nat.cast_nonneg k] | |
| theorem sampleSize_ideal_error (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) | |
| (hklo : 2 * g ≤ 3 * k) : | |
| |(sampleSize g k : ℝ) - (g : ℝ) * | |
| ((k : ℝ) / (4 * g) + separatorY ((k : ℝ) / (4 * g)))| ≤ 2 := by | |
| have h : |(sampleSize g k : ℝ) - (g : ℝ) * | |
| ((k : ℝ) / (4 * g) + separatorY ((k : ℝ) / (4 * g)))| ≤ | |
| |(sampleSize g k : ℝ) - rationalBias g k| + | |
| |rationalBias g k - (g : ℝ) * | |
| ((k : ℝ) / (4 * g) + separatorY ((k : ℝ) / (4 * g)))| := abs_sub_le _ _ _ | |
| linarith [sampleSize_error g k hg hk hklo, rationalBias_error g k hg hk] | |
| theorem sampleSize_upper (g k : ℕ) (hg : 0 < g) (hk : k ≤ g) | |
| (hklo : 2 * g ≤ 3 * k) (heven : 2 ∣ g) : sampleSize g k ≤ g / 2 := by | |
| have hnonneg : 0 ≤ rationalBias g k := | |
| le_trans (by positivity) (rationalBias_bounds g k hg hk hklo).1 | |
| have hf : (sampleSize g k : ℝ) ≤ rationalBias g k := by | |
| rw [sampleSize_eq_floor g k hg hk] | |
| exact Nat.floor_le hnonneg | |
| have hhalf : ((g / 2 : ℕ) : ℝ) = (g : ℝ) / 2 := Nat.cast_div heven (by norm_num) | |
| have h : (sampleSize g k : ℝ) ≤ (g / 2 : ℕ) := by | |
| rw [hhalf] | |
| exact hf.trans (rationalBias_bounds g k hg hk hklo).2 | |
| exact_mod_cast h | |
| theorem count_le_sampleSize (g k : ℕ) (hg : 64 ≤ g) (hk : k ≤ g) | |
| (hklo : 2 * g ≤ 3 * k) (i : Fin 4) : balancedBlockCounts 4 k i ≤ sampleSize g k := by | |
| have hg0 : 0 < g := by omega | |
| have hgR : (64 : ℝ) ≤ g := by exact_mod_cast hg | |
| have hkR : (k : ℝ) ≤ g := by exact_mod_cast hk | |
| have hcount := (abs_le.mp (balancedBlockCounts_error 4 k (by decide) i)).2 | |
| have hsample := (abs_le.mp (sampleSize_error g k hg0 hk hklo)).1 | |
| have hlow := (rationalBias_bounds g k hg0 hk hklo).1 | |
| have h : (balancedBlockCounts 4 k i : ℝ) ≤ sampleSize g k := by linarith | |
| exact_mod_cast h | |
| noncomputable def rounded (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g) | |
| (hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) : SeparatorExpectation.RoundedParameters g where | |
| e := fun _ => sampleSize g k | |
| c := balancedBlockCounts 4 k | |
| density := (k : ℝ) / (4 * g) | |
| large := hg | |
| even := heven | |
| count_le := count_le_sampleSize g k hg hk hklo | |
| size_le := fun _ => (sampleSize_upper g k (by omega) hk hklo heven).trans (Nat.div_le_self _ _) | |
| feasible := fun _ => (Nat.sub_le _ _).trans (sampleSize_upper g k (by omega) hk hklo heven) | |
| density_mem := by | |
| have hgR : (0 : ℝ) < g := by exact_mod_cast (by omega : 0 < g) | |
| have hkR : (k : ℝ) ≤ g := by exact_mod_cast hk | |
| have hkloR : (2 : ℝ) * g ≤ 3 * k := by exact_mod_cast hklo | |
| constructor | |
| · apply (le_div_iff₀ (by positivity)).mpr | |
| linarith | |
| · apply (div_le_iff₀ (by positivity)).mpr | |
| linarith | |
| count_error := by | |
| intro i | |
| have he : (g : ℝ) * ((k : ℝ) / (4 * g)) = (k : ℝ) / 4 := by | |
| have hgR : (g : ℝ) ≠ 0 := by exact_mod_cast (by omega : g ≠ 0) | |
| field_simp | |
| rw [he] | |
| exact balancedBlockCounts_error 4 k (by decide) i | |
| size_error := fun _ => sampleSize_ideal_error g k (by omega) hk hklo | |
| theorem ceil_ratio (a d : ℕ) (hd : 0 < d) : | |
| ⌈(a : ℝ) / d⌉₊ = a ⌈/⌉ d := by | |
| have hdR : (0 : ℝ) < d := by exact_mod_cast hd | |
| apply Nat.le_antisymm | |
| · apply Nat.ceil_le.mpr | |
| apply (div_le_iff₀ hdR).mpr | |
| have h := (ceilDiv_le_iff_le_mul hd).mp (le_refl (a ⌈/⌉ d)) | |
| rw [mul_comm] at h | |
| exact_mod_cast h | |
| · apply (ceilDiv_le_iff_le_mul hd).mpr | |
| have h := (div_le_iff₀ hdR).mp (Nat.le_ceil ((a : ℝ) / d)) | |
| rw [mul_comm] at h | |
| exact_mod_cast h | |
| theorem familyCount_eq (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g) | |
| (hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) : | |
| familyCount g k = (rounded g k hg heven hk hklo).counts := by | |
| funext i | |
| let S := rounded g k hg heven hk hklo | |
| have hd : 0 < (g / 2).choose (sampleSize g k - balancedBlockCounts 4 k i) := | |
| Nat.choose_pos (S.feasible i) | |
| change (10 * g.choose (sampleSize g k)) ⌈/⌉ | |
| (g / 2).choose (sampleSize g k - balancedBlockCounts 4 k i) = | |
| ⌈10 / (((g / 2).choose (sampleSize g k - balancedBlockCounts 4 k i) : ℝ) / | |
| g.choose (sampleSize g k))⌉₊ | |
| rw [div_div_eq_mul_div] | |
| have he : (10 : ℝ) * (g.choose (sampleSize g k) : ℝ) = | |
| ((10 * g.choose (sampleSize g k) : ℕ) : ℝ) := by push_cast; rfl | |
| rw [he, ceil_ratio _ _ hd] | |
| end LowSpaceSubsetSum.SeparatorParameters | |
| end OAI | |