| import OAI.Combinatorics.ExpectationThreshold.ProbabilityColors |
| import Mathlib.Algebra.BigOperators.Fin |
| import Mathlib.Algebra.Order.Archimedean.Real.Basic |
| import Mathlib.Data.Nat.Find |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.NormNum |
| import Mathlib.Tactic.Positivity |
| import Lean.Elab.Tactic.Omega |
|
|
| namespace OAI |
|
|
| /-! |
| # The largest admissible scale |
|
|
| The cutoff is constructed as the first index whose next scale fails. |
| Its existence follows from the Archimedean property and the elementary |
| lower bound `scaleSum s ≥ s`. No finite search bound or computed large |
| power is used. |
| -/ |
|
|
| namespace TalagrandThreshold |
|
|
| open scoped BigOperators |
|
|
| theorem scaleSum_succ (s : ℕ) : |
| scaleSum (s + 1) = scaleSum s + (256 : ℝ) ^ (s + 1) := by |
| simp only [scaleSum, Fin.sum_univ_castSucc, Fin.val_castSucc, Fin.val_last] |
|
|
| theorem scaleSum_monotone : Monotone scaleSum := by |
| apply monotone_nat_of_le_succ |
| intro s |
| rw [scaleSum_succ] |
| exact le_add_of_nonneg_right (by positivity) |
|
|
| theorem scaleSum_ge_nat (s : ℕ) : (s : ℝ) ≤ scaleSum s := by |
| calc |
| (s : ℝ) = ∑ _i : Fin s, (1 : ℝ) := by simp |
| _ ≤ scaleSum s := by |
| unfold scaleSum |
| exact Finset.sum_le_sum fun _ _ => one_le_pow₀ (by norm_num : (1 : ℝ) ≤ 256) |
|
|
| / |
| theorem scaleSum_le_two_pow (s : ℕ) : scaleSum s ≤ 2 * (256 : ℝ) ^ s := by |
| induction s with |
| | zero => simp [scaleSum_zero] |
| | succ s ih => |
| rw [scaleSum_succ, pow_succ (256 : ℝ) s] |
| have hpow : 0 ≤ (256 : ℝ) ^ s := by positivity |
| nlinarith |
|
|
| private theorem half_geometric_sum_identity (s : ℕ) : |
| (∑ i : Fin s, (1 / 2 : ℝ) ^ (i.val + 1)) + (1 / 2 : ℝ) ^ s = 1 := by |
| induction s with |
| | zero => simp |
| | succ s ih => |
| simp only [Fin.sum_univ_castSucc, Fin.val_castSucc, Fin.val_last] |
| rw [pow_succ (1 / 2 : ℝ) s] |
| nlinarith |
|
|
| theorem half_geometric_sum_le_one (s : ℕ) : |
| (∑ i : Fin s, (1 / 2 : ℝ) ^ (i.val + 1)) ≤ 1 := by |
| have h := half_geometric_sum_identity s |
| have hpow : 0 ≤ (1 / 2 : ℝ) ^ s := by positivity |
| linarith |
|
|
| / |
| theorem scale_next_fail_exists {p : ℝ} (hp : 0 < p) : |
| ∃ s : ℕ, 1 / 2 < p * scaleSum (s + 1) := by |
| obtain ⟨n, hn⟩ := exists_nat_gt ((1 / 2 : ℝ) / p) |
| refine ⟨n, ?_⟩ |
| have hnp : (1 / 2 : ℝ) < (n : ℝ) * p := (div_lt_iff₀ hp).mp hn |
| have hcast : (n : ℝ) ≤ (n + 1 : ℕ) := by |
| simp only [Nat.cast_add, Nat.cast_one] |
| linarith |
| calc |
| (1 / 2 : ℝ) < p * (n : ℝ) := by simpa only [mul_comm] using hnp |
| _ ≤ p * scaleSum (n + 1) := |
| mul_le_mul_of_nonneg_left (hcast.trans (scaleSum_ge_nat (n + 1))) hp.le |
|
|
| / |
| noncomputable def maxScale (p : ℝ) : ℕ := by |
| classical |
| exact if hp : 0 < p then Nat.find (scale_next_fail_exists hp) else 0 |
|
|
| private theorem maxScale_eq_find {p : ℝ} (hp : 0 < p) : |
| maxScale p = Nat.find (scale_next_fail_exists hp) := by |
| classical |
| simp only [maxScale, dite_eq_left hp] |
|
|
| theorem maxScale_next_fail {p : ℝ} (hp : 0 < p) : |
| 1 / 2 < p * scaleSum (maxScale p + 1) := by |
| classical |
| rw [maxScale_eq_find hp] |
| exact Nat.find_spec (scale_next_fail_exists hp) |
|
|
| theorem maxScale_admissible {p : ℝ} (hp : 0 < p) : |
| p * scaleSum (maxScale p) ≤ 1 / 2 := by |
| classical |
| cases hs : maxScale p with |
| | zero => simp [scaleSum_zero] |
| | succ s => |
| have hslt : s < Nat.find (scale_next_fail_exists hp) := by |
| rw [← maxScale_eq_find hp, hs] |
| exact Nat.lt_succ_self s |
| exact le_of_not_gt (Nat.find_min (scale_next_fail_exists hp) hslt) |
|
|
| / |
| theorem maxScale_largest {p : ℝ} (hp : 0 < p) {t : ℕ} |
| (ht : p * scaleSum t ≤ 1 / 2) : t ≤ maxScale p := by |
| by_contra h |
| have hst : maxScale p + 1 ≤ t := by omega |
| have hle : p * scaleSum (maxScale p + 1) ≤ p * scaleSum t := |
| mul_le_mul_of_nonneg_left (scaleSum_monotone hst) hp.le |
| exact (not_le_of_gt (maxScale_next_fail hp)) (hle.trans ht) |
|
|
| / |
| theorem exists_scale {p : ℝ} (hp : 0 < p) : |
| ∃ s : ℕ, p * scaleSum s ≤ 1 / 2 ∧ 1 / 2 < p * scaleSum (s + 1) := |
| ⟨maxScale p, maxScale_admissible hp, maxScale_next_fail hp⟩ |
|
|
| / |
| theorem tail_lt_four_mul_p {p : ℝ} {s : ℕ} (hp : 0 < p) |
| (hnext : 1 / 2 < p * scaleSum (s + 1)) : |
| 1 / (512 : ℝ) ^ (s + 1) < 4 * p := by |
| have hsum : p * scaleSum (s + 1) ≤ p * (2 * (256 : ℝ) ^ (s + 1)) := |
| mul_le_mul_of_nonneg_left (scaleSum_le_two_pow (s + 1)) hp.le |
| have hDpos : 0 < (256 : ℝ) ^ (s + 1) := by positivity |
| have hDB : (256 : ℝ) ^ (s + 1) ≤ (512 : ℝ) ^ (s + 1) := |
| pow_le_pow_left₀ (by norm_num) (by norm_num) _ |
| calc |
| 1 / (512 : ℝ) ^ (s + 1) ≤ 1 / (256 : ℝ) ^ (s + 1) := |
| one_div_le_one_div_of_le hDpos hDB |
| _ < 4 * p := by |
| apply (div_lt_iff₀ hDpos).mpr |
| nlinarith |
|
|
| theorem maxScale_tail_lt {p : ℝ} (hp : 0 < p) : |
| 1 / (512 : ℝ) ^ (maxScale p + 1) < 4 * p := |
| tail_lt_four_mul_p hp (maxScale_next_fail hp) |
|
|
| end TalagrandThreshold |
|
|
| end OAI |
|
|
