| import Mathlib |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets.Coefficient |
| open scoped BigOperators Classical |
|
|
| noncomputable def normalizer (m : ℕ) (ρ : ℝ) : ℝ := ∑ k : Fin (m+1), ρ^k.val |
| noncomputable def levelMass (m : ℕ) (ρ : ℝ) (k : Fin (m+1)) : ℝ := |
| ρ^k.val / normalizer m ρ |
| noncomputable def mass {ι : Type*} [Fintype ι] (m : ℕ) (ρ : ℝ) |
| (t : ι → Fin (m+1)) : ℝ := ∏ i, levelMass m ρ (t i) |
|
|
| lemma normalizer_pos (m : ℕ) {ρ : ℝ} (hρ : 0 ≤ ρ) : 0 < normalizer m ρ := by |
| apply Finset.sum_pos' |
| · intro i _ |
| exact pow_nonneg hρ _ |
| · exact ⟨0, Finset.mem_univ _, by simp⟩ |
|
|
| lemma levelMass_pos (m : ℕ) {ρ : ℝ} (hρ : 0 < ρ) (k : Fin (m+1)) : |
| 0 < levelMass m ρ k := div_pos (pow_pos hρ _) (normalizer_pos m hρ.le) |
|
|
| lemma levelMass_nonneg (m : ℕ) {ρ : ℝ} (hρ : 0 ≤ ρ) (k : Fin (m+1)) : |
| 0 ≤ levelMass m ρ k := div_nonneg (pow_nonneg hρ _) (normalizer_pos m hρ).le |
|
|
| lemma levelMass_total (m : ℕ) {ρ : ℝ} (hρ : 0 ≤ ρ) : |
| ∑ k, levelMass m ρ k = 1 := by |
| simp only [levelMass, ← Finset.sum_div] |
| exact div_self (normalizer_pos m hρ).ne' |
|
|
| lemma mass_nonneg {ι : Type*} [Fintype ι] (m : ℕ) {ρ : ℝ} (hρ : 0 ≤ ρ) |
| (t : ι → Fin (m+1)) : 0 ≤ mass m ρ t := |
| Finset.prod_nonneg (fun _ _ => levelMass_nonneg m hρ _) |
|
|
| lemma mass_total {ι : Type*} [Fintype ι] [DecidableEq ι] (m : ℕ) {ρ : ℝ} (hρ : 0 ≤ ρ) : |
| ∑ t : ι → Fin (m+1), mass m ρ t = 1 := by |
| simp only [mass] |
| rw [← Fintype.prod_sum] |
| simp [levelMass_total m hρ] |
|
|
| noncomputable def lower {ι : Type*} [DecidableEq ι] {m : ℕ} |
| (i : ι) (t : ι → Fin (m+1)) : ι → Fin (m+1) := |
| Function.update t i ⟨(t i).val - 1, by omega⟩ |
|
|
| lemma lower_injective_on_positive {ι : Type*} [DecidableEq ι] {m : ℕ} (i : ι) |
| {t u : ι → Fin (m+1)} (ht : 0 < (t i).val) (hu : 0 < (u i).val) |
| (he : lower i t = lower i u) : t = u := by |
| funext j |
| by_cases hji : j = i |
| · subst j |
| have h := congrArg (fun v => (v i).val) he |
| simp only [lower, Function.update_self] at h |
| exact Fin.ext (by omega) |
| · simpa only [lower, Function.update_of_ne hji] using congrFun he j |
|
|
| lemma levelMass_lower {m : ℕ} {ρ : ℝ} (k : Fin (m+1)) (hk : 0 < k.val) : |
| levelMass m ρ k = ρ * levelMass m ρ ⟨k.val-1, by omega⟩ := by |
| dsimp [levelMass] |
| have he : k.val = (k.val-1)+1 := by omega |
| conv_lhs => rw [he] |
| rw [pow_succ] |
| ring |
|
|
| lemma mass_lower {ι : Type*} [Fintype ι] [DecidableEq ι] {m : ℕ} {ρ : ℝ} |
| (i : ι) (t : ι → Fin (m+1)) (ht : 0 < (t i).val) : |
| mass m ρ t = ρ * mass m ρ (lower i t) := by |
| have he : (fun j => levelMass m ρ (lower i t j)) = |
| Function.update (fun j => levelMass m ρ (t j)) i |
| (levelMass m ρ ⟨(t i).val - 1, by omega⟩) := by |
| funext j |
| by_cases hj : j = i <;> simp [lower, hj] |
| change ∏ j, levelMass m ρ (t j) = ρ * ∏ j, levelMass m ρ (lower i t j) |
| rw [he, Finset.prod_update_of_mem (Finset.mem_univ i)] |
| rw [← Finset.mul_prod_erase _ _ (Finset.mem_univ i), levelMass_lower (t i) ht] |
| simp only [Finset.sdiff_singleton_eq_erase] |
| ring |
|
|
| theorem one_level_event_bound {ι : Type*} [Fintype ι] [DecidableEq ι] |
| {m : ℕ} {ρ : ℝ} (hρ : 0 ≤ ρ) (i : ι) |
| (high low : (ι → Fin (m+1)) → Prop) |
| (hstep : ∀ t, 0 < (t i).val → high t → low (lower i t)) : |
| (∑ t ∈ Finset.univ.filter (fun t => 0 < (t i).val ∧ high t), mass m ρ t) ≤ |
| ρ * ∑ t ∈ Finset.univ.filter low, mass m ρ t := by |
| let A := Finset.univ.filter (fun t => 0 < (t i).val ∧ high t) |
| have himage : A.image (lower i) ⊆ Finset.univ.filter low := by |
| intro u hu |
| obtain ⟨t, ht, rfl⟩ := Finset.mem_image.mp hu |
| have ht' := (Finset.mem_filter.mp ht).2 |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hstep t ht'.1 ht'.2⟩ |
| have hinj : Set.InjOn (lower (m:=m) i) (A : Set (ι → Fin (m+1))) := by |
| intro t ht u hu he |
| exact lower_injective_on_positive i (Finset.mem_filter.mp ht).2.1 |
| (Finset.mem_filter.mp hu).2.1 he |
| calc |
| _ = ρ * ∑ t ∈ A, mass m ρ (lower i t) := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro t ht |
| exact mass_lower i t (Finset.mem_filter.mp ht).2.1 |
| _ = ρ * ∑ u ∈ A.image (lower i), mass m ρ u := by rw [Finset.sum_image hinj] |
| _ ≤ _ := mul_le_mul_of_nonneg_left |
| (Finset.sum_le_sum_of_subset_of_nonneg himage (fun u _ _ => mass_nonneg m hρ u)) hρ |
|
|
| theorem positive_coefficient_bound {ι : Type*} [Fintype ι] [DecidableEq ι] |
| {m : ℕ} {ρ β K : ℝ} (hρ : 0 ≤ ρ) |
| (D : (ι → Fin (m+1)) → ι → ℝ) |
| (hstep : ∀ t i, 0 < (t i).val → |D t i - D (lower i t) i| < β/2) |
| (hcount : ∀ t, ((Finset.univ.filter (fun i => β/2 ≤ D t i)).card : ℝ) ≤ K) : |
| (∑ t ∈ Finset.univ.filter (fun t => ∃ i, 0 < (t i).val ∧ β ≤ D t i), mass m ρ t) ≤ |
| ρ*K := by |
| let A : ι → Finset (ι → Fin (m+1)) := fun i => |
| Finset.univ.filter (fun t => 0 < (t i).val ∧ β ≤ D t i) |
| have hpoint (t : ι → Fin (m+1)) : |
| (if ∃ i, 0 < (t i).val ∧ β ≤ D t i then mass m ρ t else 0) ≤ |
| ∑ i, if 0 < (t i).val ∧ β ≤ D t i then mass m ρ t else 0 := by |
| split_ifs with ht |
| · obtain ⟨i, hi⟩ := ht |
| calc |
| _ = if 0 < (t i).val ∧ β ≤ D t i then mass m ρ t else 0 := by rw [ite_eq_left hi] |
| _ ≤ _ := Finset.single_le_sum (f := fun j : ι => |
| if 0 < (t j).val ∧ β ≤ D t j then mass m ρ t else 0) |
| (fun j _ => by split_ifs <;> first | exact mass_nonneg m hρ t | exact le_rfl) |
| (Finset.mem_univ i) |
| · exact Finset.sum_nonneg (fun i _ => by |
| split_ifs <;> first | exact mass_nonneg m hρ t | exact le_rfl) |
| calc |
| _ ≤ ∑ i, ∑ t ∈ A i, mass m ρ t := by |
| simp only [Finset.sum_filter, A] |
| rw [Finset.sum_comm] |
| exact Finset.sum_le_sum (fun t _ => hpoint t) |
| _ ≤ ∑ i, ρ * ∑ t ∈ Finset.univ.filter (fun t => β/2 ≤ D t i), mass m ρ t := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply one_level_event_bound hρ i |
| intro t ht hd |
| have hs := (abs_lt.mp (hstep t i ht)).2 |
| linarith |
| _ = ρ * ∑ t, mass m ρ t * ((Finset.univ.filter (fun i => β/2 ≤ D t i)).card : ℝ) := by |
| rw [← Finset.mul_sum] |
| congr 1 |
| simp only [Finset.sum_filter] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro t _ |
| rw [← Finset.sum_filter] |
| simp [Finset.sum_const, nsmul_eq_mul, mul_comm] |
| _ ≤ ρ * ∑ t : ι → Fin (m+1), mass m ρ t * K := by |
| apply mul_le_mul_of_nonneg_left _ hρ |
| apply Finset.sum_le_sum |
| intro t _ |
| exact mul_le_mul_of_nonneg_left (hcount t) (mass_nonneg m hρ t) |
| _ = ρ*K := by |
| rw [← Finset.sum_mul] |
| have hm : (∑ t : ι → Fin (m+1), mass m ρ t) = 1 := mass_total (ι:=ι) m hρ |
| rw [hm, one_mul] |
|
|
| end LargeIndependentSets.Coefficient |
|
|
| end OAI |
|
|
