| import OAI.Combinatorics.ExpectationThreshold.SelectorTruncationDefinitions |
| import Mathlib.Data.Finset.Max |
| import Mathlib.Algebra.Order.BigOperators.Group.Finset |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| /-! |
| |
|
|
| A finite minimum provides an actual larger cutoff below every currently |
| heavy weight. Between these cutoffs the truncated excess has the exact |
| affine increment contributed by the heavy coordinates. Weights equal to |
| the original cutoff remain saturated, including when the cutoff is zero. |
| -/ |
|
|
| namespace TalagrandThreshold.Selector |
|
|
| open scoped BigOperators |
|
|
| variable {α : Type*} [Fintype α] [DecidableEq α] |
| |
| omit [DecidableEq α] in |
| /-- There is a strictly larger cutoff, at most one, that does not pass any |
| weight strictly above the current cutoff. -/ |
| theorem exists_short_right_cutoff (w : α → ℝ) {ε : ℝ} (hε : ε < 1) : |
| ∃ u : ℝ, ε < u ∧ u ≤ 1 ∧ ∀ x, ε < w x → u ≤ w x := by |
| classical |
| let S : Finset ℝ := insert 1 ((heavySet w ε).image w) |
| have hS : S.Nonempty := ⟨1, Finset.mem_insert_self _ _⟩ |
| refine ⟨S.min' hS, ?_, S.min'_le 1 (Finset.mem_insert_self _ _), ?_⟩ |
| · apply (Finset.lt_min'_iff S hS).2 |
| intro y hy |
| rcases Finset.mem_insert.mp hy with rfl | hy |
| · exact hε |
| · obtain ⟨x, hx, rfl⟩ := Finset.mem_image.mp hy |
| exact mem_heavySet.mp hx |
| · intro x hx |
| apply S.min'_le (w x) |
| exact Finset.mem_insert_of_mem |
| (Finset.mem_image.mpr ⟨x, mem_heavySet.mpr hx, rfl⟩) |
|
|
| /-- On the first interval to the right of a cutoff, precisely the strictly |
| heavy coordinates vary. The inclusion in `A` makes their coefficient `d`. -/ |
| theorem truncatedExcess_sub_eq_heavy_increment (w : α → ℝ) (A : Finset α) |
| (d ε u : ℝ) (hεu : ε ≤ u) |
| (hupper : ∀ x, ε < w x → u ≤ w x) |
| (hheavy : ∀ x, ε < w x → x ∈ A) : |
| truncatedExcess w A d u - truncatedExcess w A d ε = |
| (u - ε) * d * ((heavySet w ε).card : ℝ) := by |
| classical |
| calc |
| truncatedExcess w A d u - truncatedExcess w A d ε = |
| ∑ x, if ε < w x then (u - ε) * d else 0 := by |
| unfold truncatedExcess |
| rw [← Finset.sum_sub_distrib] |
| apply Finset.sum_congr rfl |
| intro x _ |
| by_cases hx : ε < w x |
| · simp only [min_eq_right (hupper x hx), min_eq_right hx.le, |
| ite_eq_left hx, ite_eq_left (hheavy x hx)] |
| ring |
| · have hxε : w x ≤ ε := le_of_not_gt hx |
| simp only [min_eq_left (hxε.trans hεu), min_eq_left hxε, |
| ite_eq_right hx, sub_self] |
| _ = ∑ x ∈ heavySet w ε, (u - ε) * d := by |
| rw [← Finset.sum_filter] |
| rfl |
| _ = (u - ε) * d * ((heavySet w ε).card : ℝ) := by |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| ring |
|
|
| /-- The cardinality conclusion of maximal truncation. Existence of a |
| maximal admissible cutoff is supplied separately by compactness. -/ |
| theorem maximal_admissible_card_bound (w : α → ℝ) (A : Finset α) (m d ε : ℝ) |
| (hwnonneg : ∀ x, 0 ≤ w x) (hwsum : ∑ x, w x = 1) |
| (hm0 : 0 ≤ m) (_hd0 : 0 < d) (_hd1 : d < 1) |
| (hε : Admissible w A m d ε) |
| (hmax : ∀ u : ℝ, Admissible w A m d u → u ≤ ε) : |
| d * ((heavySet w ε).card : ℝ) ≤ m := by |
| classical |
| have hwle (x : α) : w x ≤ 1 := by |
| calc |
| w x ≤ ∑ y, w y := |
| Finset.single_le_sum (fun y _ => hwnonneg y) (Finset.mem_univ x) |
| _ = 1 := hwsum |
| by_cases hεone : ε = 1 |
| · have hempty : heavySet w ε = ∅ := by |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro x hx |
| have hlt := mem_heavySet.mp hx |
| rw [hεone] at hlt |
| exact (not_lt_of_ge (hwle x)) hlt |
| simpa only [hempty, Finset.card_empty, Nat.cast_zero, mul_zero] using hm0 |
| · have hεlt : ε < 1 := lt_of_le_of_ne hε.2.1 hεone |
| obtain ⟨u, hεu, hu1, hupper⟩ := exists_short_right_cutoff w hεlt |
| by_contra hbound |
| have hgap : m < d * ((heavySet w ε).card : ℝ) := lt_of_not_ge hbound |
| have haffine := truncatedExcess_sub_eq_heavy_increment w A d ε u |
| hεu.le hupper hε.2.2.1 |
| have hslope : 0 ≤ (u - ε) * (d * ((heavySet w ε).card : ℝ) - m) := |
| mul_nonneg (sub_nonneg.mpr hεu.le) (sub_nonneg.mpr hgap.le) |
| have htest : m * u ≤ truncatedExcess w A d u := by |
| have htestε := hε.2.2.2 |
| nlinarith |
| have hu : Admissible w A m d u := |
| ⟨hε.1.trans hεu.le, hu1, |
| fun x hx => hε.2.2.1 x (hεu.trans hx), htest⟩ |
| exact (not_lt_of_ge (hmax u hu)) hεu |
|
|
| end TalagrandThreshold.Selector |
|
|
| end OAI |
|
|
