| import OAI.Geometry.PinnedDistances.ArithmeticVariance |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 |
|
|
| section |
| noncomputable section |
| open NumberField |
| open scoped BigOperators |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology ENNReal |
| noncomputable section |
| open MeasureTheory NumberField |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u1} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| def sourceGiant (x : P) (r : ℝ) : Prop := Fintype.card P < 2*(d.cell r x).card |
| instance (x : P) (r : ℝ) : Decidable (d.sourceGiant x r) := Classical.propDecidable _ |
|
|
| omit [DecidableEq P] in |
| lemma sourceGiant_mono (x : P) {r t : ℝ} (htr : t ≤ r) (hr : d.sourceGiant x r) : |
| d.sourceGiant x t := by |
| classical |
| have hc := Finset.card_le_card (d.cell_mono htr x) |
| unfold sourceGiant at * |
| omega |
|
|
| omit [DecidableEq P] in |
| lemma sourceGiant_iff (x : P) (r : ℝ) : d.sourceGiant x r ↔ |
| ∃ C : Finset P, Fintype.card P < 2*C.card ∧ ∀ y ∈ C, d.share r x y := by |
| classical |
| constructor |
| · intro h; exact ⟨d.cell r x,h,fun y hy => (d.mem_cell r x y).mp hy⟩ |
| · rintro ⟨C,hc,hC⟩ |
| have hsub : C ⊆ d.cell r x := fun y hy => (d.mem_cell r x y).mpr (hC y hy) |
| have := Finset.card_le_card hsub |
| unfold sourceGiant |
| omega |
|
|
| lemma isClosed_sourceGiant (x : P) : IsClosed {r : ℝ | d.sourceGiant x r} := by |
| classical |
| simp_rw [d.sourceGiant_iff, Set.ofPred_exists] |
| apply isClosed_iUnion_of_finite |
| intro C |
| simp only [Set.ofPred_and] |
| apply IsClosed.inter |
| · by_cases h : Fintype.card P < 2*C.card <;> simp [h] |
| · simp_rw [Set.ofPred_forall] |
| apply isClosed_iInter |
| intro y |
| apply isClosed_iInter |
| intro hy |
| by_cases hxy : x = y |
| · simp [share,hxy] |
| · simp only [share,hxy,false_or] |
| exact isClosed_le continuous_id continuous_const |
|
|
| def sourceM (x : P) : ℝ := sSup {r : ℝ | d.sourceGiant x r} |
|
|
| lemma sourceGiant_cutoff (hn : 2 ≤ Fintype.card P) (x : P) (r : ℝ) : |
| d.sourceGiant x r ↔ r ≤ d.sourceM x := by |
| classical |
| have hlo : d.sourceGiant x (-d.radius) := by |
| classical |
| unfold sourceGiant |
| rw [d.cell_of_low le_rfl,Finset.card_univ] |
| omega |
| have hle : ∀ t, d.sourceGiant x t → t ≤ d.radius := by |
| classical |
| intro t ht |
| exact d.giants_le_radius hn ⟨d.cell t x, (d.mem_giants t _).mpr ⟨d.cell_mem_cells t x,ht⟩⟩ |
| have hne : Set.Nonempty {t : ℝ | d.sourceGiant x t} := ⟨-d.radius,hlo⟩ |
| have hbd : BddAbove {t : ℝ | d.sourceGiant x t} := ⟨d.radius, fun t ht => hle t ht⟩ |
| have hmem : d.sourceGiant x (d.sourceM x) := (d.isClosed_sourceGiant x).csSup_mem hne hbd |
| exact ⟨fun hr => le_csSup hbd hr, fun hr => d.sourceGiant_mono x hr hmem⟩ |
|
|
| lemma sourceM_le_M (hn : 2 ≤ Fintype.card P) (x : P) : d.sourceM x ≤ d.M := by |
| classical |
| apply (d.giants_cutoff hn _).mp |
| exact ⟨d.cell (d.sourceM x) x, (d.mem_giants _ _).mpr |
| ⟨d.cell_mem_cells _ x,(d.sourceGiant_cutoff hn x _).mpr le_rfl⟩⟩ |
|
|
| lemma sourceGiant_mem_giant (x : P) (r : ℝ) : |
| d.sourceGiant x r ↔ (d.giants r).Nonempty ∧ x ∈ d.giant r := by |
| classical |
| constructor |
| · intro hs |
| have hc : d.cell r x ∈ d.giants r := (d.mem_giants r _).mpr ⟨d.cell_mem_cells r x,hs⟩ |
| exact ⟨⟨_,hc⟩,by rw [d.giant_eq hc]; exact d.self_mem_cell r x⟩ |
| · rintro ⟨⟨G,hG⟩,hx⟩ |
| rw [d.giant_eq hG] at hx |
| obtain ⟨hGc,hGm⟩ := (d.mem_giants r G).mp hG |
| rwa [d.cell_of_mem hGc hx] at hGm |
|
|
| lemma outsideIndicator_source (hn : 2 ≤ Fintype.card P) (x : P) (r : ℝ) : |
| d.outsideIndicator r x = if d.sourceM x < r ∧ r ≤ d.M then 1 else 0 := by |
| classical |
| have he : ((d.giants r).Nonempty ∧ x ∉ d.giant r) ↔ d.sourceM x < r ∧ r ≤ d.M := by |
| classical |
| rw [← not_le, ← d.sourceGiant_cutoff hn x r, d.sourceGiant_mem_giant, |
| ← d.giants_cutoff hn r] |
| tauto |
| simp only [outsideIndicator,he] |
|
|
| lemma potential_source (hn : 2 ≤ Fintype.card P) (x : P) : |
| d.potential x = d.M - d.sourceM x := by |
| classical |
| have he : (fun r => d.outsideIndicator r x) = |
| (Set.Ioc (d.sourceM x) d.M).indicator (fun _ : ℝ => (1:ℝ)) := by |
| classical |
| funext r |
| simp only [d.outsideIndicator_source hn, Set.indicator_apply, Set.mem_Ioc] |
| rw [potential,he,integral_indicator measurableSet_Ioc] |
| rw [← intervalIntegral.integral_of_le (d.sourceM_le_M hn x), intervalIntegral.integral_const] |
| simp |
|
|
| /-- The level set is an interval of length 2H, regardless of the fiber center-level h. -/ |
|
|
| lemma straddle_integral (hn : 2 ≤ Fintype.card P) (x : P) (h H : ℝ) (hH : 0 ≤ H) : |
| (∫ r : ℝ, if d.sourceGiant x (h-r-H) ∧ ¬d.sourceGiant x (h-r+H) then (1:ℝ) else 0) = 2*H := by |
| classical |
| have he : (fun r : ℝ => if d.sourceGiant x (h-r-H) ∧ ¬d.sourceGiant x (h-r+H) then (1:ℝ) else 0) = |
| (Set.Ico (h-H-d.sourceM x) (h+H-d.sourceM x)).indicator (fun _ => (1:ℝ)) := by |
| classical |
| funext r |
| simp only [d.sourceGiant_cutoff hn, not_le,Set.indicator_apply,Set.mem_Ico] |
| congr 1 |
| apply propext |
| constructor <;> rintro ⟨h₁,h₂⟩ <;> constructor <;> linarith |
| rw [he,integral_indicator measurableSet_Ico] |
| rw [integral_Ico_eq_integral_Ioc, ← intervalIntegral.integral_of_le (by linarith : h-H-d.sourceM x ≤ h+H-d.sourceM x), intervalIntegral.integral_const] |
| simp |
| ring |
|
|
| def smallCells (y : P) (T : ℝ) : Finset (Finset P) := by |
| classical |
| exact Finset.univ.filter (fun C => ∃ r : ℝ, C = d.cell r y ∧ (C.card : ℝ) < T) |
|
|
| def smallNeighbors (y : P) (T : ℝ) : Finset P := (d.smallCells y T).biUnion id |
|
|
| omit [DecidableEq P] in |
| lemma smallCells_chain (y : P) (T : ℝ) {C E : Finset P} |
| (hC : C ∈ d.smallCells y T) (hE : E ∈ d.smallCells y T) : C ⊆ E ∨ E ⊆ C := by |
| classical |
| obtain ⟨r,rfl,hr⟩ := (Finset.mem_filter.mp hC).2 |
| obtain ⟨t,rfl,ht⟩ := (Finset.mem_filter.mp hE).2 |
| rcases le_total t r with h | h |
| · exact Or.inl (d.cell_mono h y) |
| · exact Or.inr (d.cell_mono h y) |
|
|
| lemma smallNeighbors_card (y : P) (T : ℝ) (hT : 0 < T) : |
| ((d.smallNeighbors y T).card : ℝ) < T := by |
| classical |
| by_cases hne : (d.smallCells y T).Nonempty |
| · obtain ⟨C,hC,hmax⟩ := Finset.exists_max_image (d.smallCells y T) Finset.card hne |
| have he : d.smallNeighbors y T = C := by |
| classical |
| apply Finset.Subset.antisymm |
| · intro x hx |
| obtain ⟨E,hE,hx⟩ := Finset.mem_biUnion.mp hx |
| change x ∈ E at hx |
| rcases d.smallCells_chain y T hE hC with h | h |
| · exact h hx |
| · have he : C = E := Finset.eq_of_subset_of_card_le h (hmax E hE) |
| simpa only [he] using hx |
| · intro x hx |
| exact Finset.mem_biUnion.mpr ⟨C,hC,hx⟩ |
| rw [he] |
| obtain ⟨r,hr,ht⟩ := (Finset.mem_filter.mp hC).2 |
| exact ht |
| · rw [smallNeighbors,Finset.not_nonempty_iff_eq_empty.mp hne] |
| simpa using hT |
|
|
| lemma source_mem_smallNeighbors (y x : P) (r T : ℝ) |
| (hxy : y ∈ d.cell r x) (hT : ((d.cell r x).card : ℝ) < T) : |
| x ∈ d.smallNeighbors y T := by |
| classical |
| have he := d.cell_eq_of_share ((d.mem_cell r x y).mp hxy) |
| apply Finset.mem_biUnion.mpr |
| refine ⟨d.cell r y, ?_, (d.mem_cell r y x).mpr (d.share_symm ((d.mem_cell r x y).mp hxy))⟩ |
| apply Finset.mem_filter.mpr |
| exact ⟨Finset.mem_univ _,r,rfl,by rwa [← he]⟩ |
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u2} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| lemma smallNeighbors_self (y : P) (T : ℝ) (hne : (d.smallNeighbors y T).Nonempty) : |
| y ∈ d.smallNeighbors y T := by |
| classical |
| obtain ⟨x,hx⟩ := hne |
| obtain ⟨C,hC,hx⟩ := Finset.mem_biUnion.mp hx |
| obtain ⟨r,rfl,hr⟩ := (Finset.mem_filter.mp hC).2 |
| apply Finset.mem_biUnion.mpr |
| exact ⟨d.cell r y,hC,d.self_mem_cell r y⟩ |
|
|
| lemma smallNeighbors_erase_bound (hn : 2 ≤ Fintype.card P) (y : P) |
| (τ : ℝ) (hτ : 0 < τ) (hτ1 : τ ≤ 1) : |
| ((d.smallNeighbors y (τ*Fintype.card P)).erase y).card ≤ τ*((Fintype.card P : ℝ)-1) := by |
| classical |
| have hn0 : 0 < (Fintype.card P : ℝ) := by exact_mod_cast (show 0 < Fintype.card P by omega) |
| have hn1 : 0 ≤ (Fintype.card P : ℝ)-1 := by |
| have : (2:ℝ) ≤ Fintype.card P := by exact_mod_cast hn |
| linarith |
| by_cases hne : (d.smallNeighbors y (τ*Fintype.card P)).Nonempty |
| · have hy := d.smallNeighbors_self y _ hne |
| have hc := d.smallNeighbors_card y (τ*Fintype.card P) (mul_pos hτ hn0) |
| rw [Finset.card_erase_of_mem hy,Nat.cast_sub (Finset.one_le_card.mpr hne),Nat.cast_one] |
| nlinarith |
| · rw [Finset.not_nonempty_iff_eq_empty.mp hne] |
| simp only [Finset.erase_empty,Finset.card_empty,Nat.cast_zero] |
| exact mul_nonneg hτ.le hn1 |
|
|
| /-- All candidate sources for each target lie in one small neighborhood, |
| allowing a level-dependent fiber reparametrization. -/ |
|
|
| lemma smallNeighbors_pair_bound (hn : 2 ≤ Fintype.card P) |
| (q : P → P → ℝ) (B τ : ℝ) (hB : 0 ≤ B) (hτ : 0 < τ) (hτ1 : τ ≤ 1) |
| (hq : ∀ x y, x ≠ y → q x y ≤ B / ((Fintype.card P : ℝ)*((Fintype.card P : ℝ)-1))) |
| (C : Finset P) : |
| (∑ y ∈ C, ∑ x ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, q x y) ≤ |
| B*τ*((C.card : ℝ)/Fintype.card P) := by |
| classical |
| have hn0 : 0 < (Fintype.card P : ℝ) := by exact_mod_cast (show 0 < Fintype.card P by omega) |
| have hn1 : 0 < (Fintype.card P : ℝ)-1 := by |
| have : (2:ℝ) ≤ Fintype.card P := by exact_mod_cast hn |
| linarith |
| have hden : 0 ≤ B / ((Fintype.card P : ℝ)*((Fintype.card P : ℝ)-1)) := |
| div_nonneg hB (mul_pos hn0 hn1).le |
| have hy (y : P) : (∑ x ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, q x y) ≤ |
| B*τ/Fintype.card P := by |
| classical |
| calc |
| _ ≤ ∑ x ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, |
| B / ((Fintype.card P : ℝ)*((Fintype.card P : ℝ)-1)) := |
| Finset.sum_le_sum (fun x hx => hq x y (Finset.ne_of_mem_erase hx)) |
| _ = (((d.smallNeighbors y (τ*Fintype.card P)).erase y).card : ℝ) * |
| (B / ((Fintype.card P : ℝ)*((Fintype.card P : ℝ)-1))) := by simp |
| _ ≤ (τ*((Fintype.card P : ℝ)-1)) * |
| (B / ((Fintype.card P : ℝ)*((Fintype.card P : ℝ)-1))) := |
| mul_le_mul_of_nonneg_right (d.smallNeighbors_erase_bound hn y τ hτ hτ1) hden |
| _ = B*τ/Fintype.card P := by field_simp |
| calc |
| _ ≤ ∑ y ∈ C, B*τ/Fintype.card P := Finset.sum_le_sum (fun y _ => hy y) |
| _ = _ := by simp; ring |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.SmallFiber |
| open MeasureTheory |
| variable {P : Type u3} [Fintype P] [DecidableEq P] |
|
|
| /-- Probability of a finite subset; the fiber weights used below will be the |
| exact uniform probabilities on the original retained distance fibers. -/ |
| def mass (p : P → ℝ) (C : Finset P) : ℝ := ∑ y ∈ C, p y |
|
|
| omit [Fintype P] [DecidableEq P] in |
| lemma mass_nonneg {p : P → ℝ} (hp : ∀ y, 0 ≤ p y) (C : Finset P) : 0 ≤ mass p C := |
| Finset.sum_nonneg (fun y _ => hp y) |
|
|
| omit [Fintype P] [DecidableEq P] in |
| lemma mass_mono {p : P → ℝ} (hp : ∀ y, 0 ≤ p y) {C D : Finset P} (h : C ⊆ D) : |
| mass p C ≤ mass p D := Finset.sum_le_sum_of_subset_of_nonneg h (fun y _ _ => hp y) |
|
|
| omit [DecidableEq P] in |
| lemma mass_le_one {p : P → ℝ} (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) (C : Finset P) : |
| mass p C ≤ 1 := by rw [← h1]; exact mass_mono hp (Finset.subset_univ C) |
|
|
| omit [Fintype P] in |
| lemma mass_diff_inter (p : P → ℝ) (C D : Finset P) : |
| mass p C = mass p (C \ D) + mass p (C ∩ D) := by |
| classical |
| symm |
| have hh := Finset.sum_sdiff (f:=p) (Finset.inter_subset_left (s₁:=C) (s₂:=D)) |
| have he : C \ (C ∩ D) = C \ D := by ext y; simp |
| rw [he] at hh |
| exact hh |
|
|
| lemma mass_cover (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) |
| (C D : Finset P) : 1 ≤ mass p C + mass p D + mass p (C ∪ D)ᶜ := by |
| classical |
| rw [← h1] |
| have he := Finset.sum_compl_add_sum (C ∪ D) p |
| have hu := (Finset.sum_union_inter (s₁:=C) (s₂:=D) (f:=p)) |
| have hn := mass_nonneg hp (C ∩ D) |
| unfold mass at * |
| linarith |
|
|
| lemma small_case_one (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) |
| (C D : Finset P) (lam : ℝ) (hlam : 0 ≤ lam) (hlam2 : lam ≤ 1/2) |
| (hC : mass p C ≤ lam) : |
| mass p C ≤ 2*lam*mass p D + mass p (C ∪ D)ᶜ := by |
| classical |
| have hc := mass_cover p hp h1 C D |
| have hnC := mass_nonneg hp C |
| have hnD := mass_nonneg hp D |
| have hnE := mass_nonneg hp (C∪D)ᶜ |
| have hp2 : mass p C ≤ 1/2 := hC.trans hlam2 |
| nlinarith |
|
|
| end WeakPinned.SmallFiber |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u4} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| lemma nongiant_share_overlap {r : ℝ} {x y : P} (hg : ¬ d.sourceGiant x r) |
| (hy : y ∈ d.cell r x) : 1 ≤ d.pairOverlap r x y := by |
| classical |
| have hs := (d.mem_cell r x y).mp hy |
| rw [d.pairOverlap_formula, ite_eq_left hs] |
| by_cases he : (d.giants r).Nonempty |
| · have hx : x ∉ d.giant r := by |
| intro hx |
| exact hg ((d.sourceGiant_mem_giant x r).mpr ⟨he,hx⟩) |
| have hy' : y ∉ d.giant r := by |
| intro hy' |
| have hgy := (d.sourceGiant_mem_giant y r).mpr ⟨he,hy'⟩ |
| exact hg (by simpa only [sourceGiant, d.cell_eq_of_share hs] using hgy) |
| simp [giantIndicator,outsideIndicator,he,hx,hy'] |
| · simp [giantIndicator,outsideIndicator,he] |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.SmallFiber |
| open MeasureTheory Hierarchy |
| variable {P : Type u5} [Fintype P] [DecidableEq P] |
|
|
| lemma mass_as_sum (p : P → ℝ) (C : Finset P) : |
| mass p C = ∑ y, if y ∈ C then p y else 0 := by |
| classical |
| simp [mass] |
|
|
| lemma mass_as_sum_off (p : P → ℝ) (x : P) (hx : p x = 0) (C : Finset P) : |
| mass p C = ∑ y, if x ≠ y ∧ y ∈ C then p y else 0 := by |
| classical |
| rw [mass_as_sum] |
| apply Finset.sum_congr rfl |
| intro y _ |
| by_cases hxy : x = y |
| · subst y; simp [hx] |
| · simp [hxy] |
|
|
| lemma nongiant_mass_bound (d : Depth P) (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) |
| (x : P) (r : ℝ) : |
| (if ¬d.sourceGiant x r then mass p (d.cell r x) else 0) ≤ |
| ∑ y, p y * d.pairOverlap r x y := by |
| classical |
| by_cases hg : d.sourceGiant x r |
| · simp only [hg,not_true_eq_false,ite_false] |
| exact Finset.sum_nonneg (fun y _ => mul_nonneg (hp y) (d.pairOverlap_bounds r x y).1) |
| · simp only [hg,not_false_eq_true,ite_true] |
| rw [mass_as_sum] |
| apply Finset.sum_le_sum |
| intro y _ |
| by_cases hy : y ∈ d.cell r x |
| · simp only [hy,ite_true] |
| nlinarith [d.nongiant_share_overlap hg hy, hp y] |
| · simpa only [hy,ite_false] using mul_nonneg (hp y) (d.pairOverlap_bounds r x y).1 |
|
|
| lemma integral_open_interval (a b : ℝ) : |
| (∫ r : ℝ, if a < r ∧ r < b then (1:ℝ) else 0) = max (b-a) 0 := by |
| have he : (fun r : ℝ => if a < r ∧ r < b then (1:ℝ) else 0) = |
| (Set.Ioo a b).indicator (fun _ : ℝ => (1:ℝ)) := by |
| funext r; simp [Set.indicator_apply] |
| rw [he, integral_indicator measurableSet_Ioo] |
| simp [integral_const,measureReal_def,Real.volume_Ioo,ENNReal.toReal_ofReal'] |
|
|
| lemma integral_closed_interval (a b : ℝ) : |
| (∫ r : ℝ, if a ≤ r ∧ r ≤ b then (1:ℝ) else 0) = max (b-a) 0 := by |
| have he : (fun r : ℝ => if a ≤ r ∧ r ≤ b then (1:ℝ) else 0) = |
| (Set.Icc a b).indicator (fun _ : ℝ => (1:ℝ)) := by |
| funext r; simp [Set.indicator_apply] |
| rw [he, integral_indicator measurableSet_Icc] |
| simp [integral_const,measureReal_def,Real.volume_Icc,ENNReal.toReal_ofReal'] |
|
|
| lemma integrable_open_interval (a b : ℝ) : |
| Integrable (fun r : ℝ => if a < r ∧ r < b then (1:ℝ) else 0) := by |
| have he : (fun r : ℝ => if a < r ∧ r < b then (1:ℝ) else 0) = |
| (Set.Ioo a b).indicator (fun _ : ℝ => (1:ℝ)) := by |
| funext r; simp [Set.indicator_apply] |
| rw [he, integrable_indicator_iff measurableSet_Ioo] |
| exact integrableOn_const (by rw [Real.volume_Ioo]; exact ENNReal.ofReal_ne_top) |
|
|
| lemma integrable_closed_interval (a b : ℝ) : |
| Integrable (fun r : ℝ => if a ≤ r ∧ r ≤ b then (1:ℝ) else 0) := by |
| have he : (fun r : ℝ => if a ≤ r ∧ r ≤ b then (1:ℝ) else 0) = |
| (Set.Icc a b).indicator (fun _ : ℝ => (1:ℝ)) := by |
| funext r; simp [Set.indicator_apply] |
| rw [he, integrable_indicator_iff measurableSet_Icc] |
| exact integrableOn_const (by rw [Real.volume_Icc]; exact ENNReal.ofReal_ne_top) |
|
|
| def minusError (d d' : Depth P) (p : P → ℝ) (x : P) (h H r : ℝ) : ℝ := |
| mass p (d.cell r x ∪ d'.cell (h-r-H) x)ᶜ |
|
|
| def plusError (d d' : Depth P) (p : P → ℝ) (x : P) (h H r : ℝ) : ℝ := |
| mass p (d.cell r x ∩ d'.cell (h-r+H) x) |
|
|
| lemma minusError_formula (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H r : ℝ) : |
| minusError d d' p x h H r = ∑ y, p y * |
| (if d.value x y < r ∧ r < h-H-d'.value x y then (1:ℝ) else 0) := by |
| classical |
| rw [minusError,mass_as_sum] |
| apply Finset.sum_congr rfl |
| intro y _ |
| by_cases hxy : x = y |
| · subst y; simp [hx] |
| · simp only [Finset.mem_compl,Finset.mem_union,Depth.mem_cell,Depth.share,hxy,false_or,not_or,not_le] |
| have he : (d.value x y < r ∧ d'.value x y < h-r-H) ↔ |
| d.value x y < r ∧ r < h-H-d'.value x y := by constructor <;> rintro ⟨a,b⟩ <;> constructor <;> linarith |
| simp only [he] |
| split_ifs <;> simp |
|
|
| lemma plusError_formula (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H r : ℝ) : |
| plusError d d' p x h H r = ∑ y, p y * |
| (if h+H-d'.value x y ≤ r ∧ r ≤ d.value x y then (1:ℝ) else 0) := by |
| classical |
| rw [plusError,mass_as_sum] |
| apply Finset.sum_congr rfl |
| intro y _ |
| by_cases hxy : x = y |
| · subst y; simp [hx] |
| · simp only [Finset.mem_inter,Depth.mem_cell,Depth.share,hxy,false_or] |
| have he : (r ≤ d.value x y ∧ h-r+H ≤ d'.value x y) ↔ |
| h+H-d'.value x y ≤ r ∧ r ≤ d.value x y := by constructor <;> rintro ⟨a,b⟩ <;> constructor <;> linarith |
| simp only [he] |
| split_ifs <;> simp |
|
|
| lemma minusError_integrable (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H : ℝ) : Integrable (minusError d d' p x h H) := by |
| change Integrable (fun r => minusError d d' p x h H r) |
| simp_rw [minusError_formula d d' p x hx] |
| exact integrable_finsetSum _ (fun y _ => (integrable_open_interval _ _).const_mul (p y)) |
|
|
| lemma plusError_integrable (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H : ℝ) : Integrable (plusError d d' p x h H) := by |
| change Integrable (fun r => plusError d d' p x h H r) |
| simp_rw [plusError_formula d d' p x hx] |
| exact integrable_finsetSum _ (fun y _ => (integrable_closed_interval _ _).const_mul (p y)) |
|
|
| lemma minusError_integral (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H : ℝ) : (∫ r, minusError d d' p x h H r) = |
| ∑ y, p y * max (h-d.value x y-d'.value x y-H) 0 := by |
| simp_rw [minusError_formula d d' p x hx] |
| rw [integral_finsetSum _ (fun y _ => (integrable_open_interval _ _).const_mul (p y))] |
| simp_rw [integral_const_mul,integral_open_interval] |
| apply Finset.sum_congr rfl |
| intro y _ |
| congr 2; ring |
|
|
| lemma plusError_integral (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H : ℝ) : (∫ r, plusError d d' p x h H r) = |
| ∑ y, p y * max (d.value x y+d'.value x y-h-H) 0 := by |
| simp_rw [plusError_formula d d' p x hx] |
| rw [integral_finsetSum _ (fun y _ => (integrable_closed_interval _ _).const_mul (p y))] |
| simp_rw [integral_const_mul,integral_closed_interval] |
| apply Finset.sum_congr rfl |
| intro y _ |
| congr 2; ring |
|
|
| lemma two_truncations (a H : ℝ) (hH : 0 ≤ H) : |
| max (-a-H) 0 + max (a-H) 0 = max (|a|-H) 0 := by |
| rcases le_total 0 a with ha | ha |
| · rw [abs_of_nonneg ha,max_eq_right (by linarith : -a-H ≤ 0),zero_add] |
| · rw [abs_of_nonpos ha,max_eq_right (by linarith : a-H ≤ 0),add_zero] |
|
|
| lemma errors_integral (d d' : Depth P) (p : P → ℝ) (x : P) (hx : p x = 0) |
| (h H : ℝ) (hH : 0 ≤ H) : |
| (∫ r, minusError d d' p x h H r + plusError d d' p x h H r) = |
| ∑ y, p y * max (|d.value x y+d'.value x y-h|-H) 0 := by |
| rw [integral_add (minusError_integrable d d' p x hx h H) (plusError_integrable d d' p x hx h H), |
| minusError_integral d d' p x hx, plusError_integral d d' p x hx,← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro y _ |
| have he : h-d.value x y-d'.value x y-H = -(d.value x y+d'.value x y-h)-H := by ring |
| rw [he,← mul_add,two_truncations _ H hH] |
|
|
| end WeakPinned.SmallFiber |
|
|
| namespace WeakPinned.SmallFiber |
| open MeasureTheory Hierarchy |
| variable {P : Type u6} [Fintype P] [DecidableEq P] |
|
|
| /-- Actual source cell, not a giant-complement occurrence. -/ |
| def activeMass (d : Depth P) (p : P → ℝ) (x : P) (T lam r : ℝ) : ℝ := by |
| classical |
| exact if ¬d.sourceGiant x r ∧ ((d.cell r x).card : ℝ) < T ∧ mass p (d.cell r x) < lam |
| then mass p (d.cell r x) else 0 |
|
|
| def nongiantMass (d : Depth P) (p : P → ℝ) (x : P) (r : ℝ) : ℝ := |
| if ¬d.sourceGiant x r then mass p (d.cell r x) else 0 |
|
|
| def straddle (d : Depth P) (x : P) (h H r : ℝ) : ℝ := |
| if d.sourceGiant x (h-r-H) ∧ ¬d.sourceGiant x (h-r+H) then 1 else 0 |
|
|
| def neighborMass (d d' : Depth P) (p : P → ℝ) (x : P) (T t : ℝ) : ℝ := by |
| classical |
| exact ∑ y, p y * (if x ∈ (d.smallNeighbors y T).erase y then d'.outsideIndicator t y else 0) |
|
|
| lemma neighborMass_nonneg (d d' : Depth P) (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) |
| (x : P) (T t : ℝ) : 0 ≤ neighborMass d d' p x T t := by |
| classical |
| exact Finset.sum_nonneg (fun y _ => mul_nonneg (hp y) (by split_ifs; exact (d'.outsideIndicator_bounds t y).1; rfl)) |
|
|
| omit [DecidableEq P] in |
| lemma nongiantMass_nonneg (d : Depth P) (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) |
| (x : P) (r : ℝ) : 0 ≤ nongiantMass d p x r := by |
| unfold nongiantMass |
| split_ifs <;> first | exact mass_nonneg hp _ | rfl |
|
|
| lemma case_three_bound (d d' : Depth P) (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) |
| (x : P) (hx : p x = 0) (r t T : ℝ) |
| (hT : ((d.cell r x).card : ℝ) < T) (hg : d'.sourceGiant x t) : |
| mass p (d.cell r x \ d'.cell t x) ≤ neighborMass d d' p x T t := by |
| classical |
| rw [mass_as_sum_off p x hx] |
| unfold neighborMass |
| apply Finset.sum_le_sum |
| intro y _ |
| by_cases hy : x ≠ y ∧ y ∈ d.cell r x \ d'.cell t x |
| · obtain ⟨hxy,hyD⟩ := hy |
| obtain ⟨hyU,hyV⟩ := Finset.mem_sdiff.mp hyD |
| have hn : x ∈ (d.smallNeighbors y T).erase y := |
| Finset.mem_erase.mpr ⟨hxy, d.source_mem_smallNeighbors y x r T hyU hT⟩ |
| have hG : d'.cell t x ∈ d'.giants t := (d'.mem_giants t _).mpr ⟨d'.cell_mem_cells t x,hg⟩ |
| have he : (d'.giants t).Nonempty := ⟨_,hG⟩ |
| have hyo : y ∉ d'.giant t := by rwa [d'.giant_eq hG] |
| simp [hxy,hyD,hn,Depth.outsideIndicator,he,hyo] |
| · simp only [hy,ite_false] |
| exact mul_nonneg (hp y) (by split_ifs; exact (d'.outsideIndicator_bounds t y).1; rfl) |
|
|
| /-- The pointwise small-fiber bound. The only independent error is the exact |
| pair of intervals already evaluated. -/ |
| lemma active_pointwise (d d' : Depth P) (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) |
| (h1 : ∑ y, p y = 1) (x : P) (hx : p x = 0) (h H T lam r : ℝ) |
| (hlam : 0 ≤ lam) (hlam2 : lam ≤ 1/2) : |
| activeMass d p x T lam r ≤ |
| 2*lam*nongiantMass d' p x (h-r-H) + lam*straddle d' x h H r + |
| minusError d d' p x h H r + plusError d d' p x h H r + |
| neighborMass d d' p x T (h-r+H) := by |
| classical |
| have hminus : 0 ≤ minusError d d' p x h H r := mass_nonneg hp _ |
| have hplus : 0 ≤ plusError d d' p x h H r := mass_nonneg hp _ |
| have hnbr := neighborMass_nonneg d d' p hp x T (h-r+H) |
| have hng := nongiantMass_nonneg d' p hp x (h-r-H) |
| have hstr : 0 ≤ straddle d' x h H r := by unfold straddle; split_ifs <;> norm_num |
| unfold activeMass |
| split_ifs with ha |
| · obtain ⟨haG,haT,haP⟩ := ha |
| by_cases hg : d'.sourceGiant x (h-r-H) |
| · by_cases hg' : d'.sourceGiant x (h-r+H) |
| · have hthree := case_three_bound d d' p hp x hx r (h-r+H) T haT hg' |
| have he := mass_diff_inter p (d.cell r x) (d'.cell (h-r+H) x) |
| change mass p (d.cell r x) = _ + plusError d d' p x h H r at he |
| nlinarith |
| · have hs : straddle d' x h H r = 1 := by simp [straddle,hg,hg'] |
| rw [hs] |
| nlinarith |
| · have hone := small_case_one p hp h1 (d.cell r x) (d'.cell (h-r-H) x) lam hlam hlam2 haP.le |
| have hnge : nongiantMass d' p x (h-r-H) = mass p (d'.cell (h-r-H) x) := by |
| simp [nongiantMass,hg] |
| rw [hnge] |
| change mass p (d.cell r x) ≤ _ + minusError d d' p x h H r at hone |
| nlinarith |
| · positivity |
|
|
| omit [DecidableEq P] in |
| lemma nongiantMass_measurable (d : Depth P) (p : P → ℝ) (x : P) : |
| Measurable (nongiantMass d p x) := by |
| classical |
| let f : Finset P → ℝ := fun C => if ¬Fintype.card P < 2*C.card then mass p C else 0 |
| have h := (measurable_of_finite f).comp (d.measurable_cell x) |
| have he : nongiantMass d p x = f ∘ (fun r => d.cell r x) := by |
| funext r |
| by_cases hg : Fintype.card P < 2*(d.cell r x).card |
| · simp [nongiantMass,f,Depth.sourceGiant,hg] |
| · simp [nongiantMass,f,Depth.sourceGiant,hg] |
| rw [he] |
| exact h |
|
|
| omit [DecidableEq P] in |
| lemma activeMass_measurable (d : Depth P) (p : P → ℝ) (x : P) (T lam : ℝ) : |
| Measurable (activeMass d p x T lam) := by |
| classical |
| let f : Finset P → ℝ := fun C => if ¬Fintype.card P < 2*C.card ∧ (C.card : ℝ) < T ∧ mass p C < lam |
| then mass p C else 0 |
| have h := (measurable_of_finite f).comp (d.measurable_cell x) |
| have he : activeMass d p x T lam = f ∘ (fun r => d.cell r x) := by |
| funext r |
| by_cases hg : Fintype.card P < 2*(d.cell r x).card |
| · simp [activeMass,f,Depth.sourceGiant,hg] |
| · simp [activeMass,f,Depth.sourceGiant,hg,Nat.not_lt.mp hg] |
| rw [he] |
| exact h |
|
|
| omit [DecidableEq P] in |
| lemma nongiantMass_integrable (d : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) (x : P) (hx : p x = 0) : |
| Integrable (nongiantMass d p x) := by |
| classical |
| apply Depth.integrable_supported_Icc (nongiantMass_measurable d p x) (a:=-d.radius) (b:=d.radius) (C:=1) |
| · intro r |
| rw [Real.norm_eq_abs,abs_of_nonneg (nongiantMass_nonneg d p hp x r)] |
| unfold nongiantMass |
| split_ifs <;> first | exact mass_le_one hp h1 _ | norm_num |
| · intro r hr |
| by_cases hlo : r ≤ -d.radius |
| · have hG : d.sourceGiant x r := by |
| unfold Depth.sourceGiant |
| rw [d.cell_of_low hlo x,Finset.card_univ] |
| omega |
| simp [nongiantMass,hG] |
| · have hhi : d.radius < r := by |
| by_contra! hhi |
| exact hr ⟨(not_le.mp hlo).le,hhi⟩ |
| simp only [nongiantMass] |
| rw [d.cell_of_high hhi x] |
| have he : mass p {x} = 0 := by simp [mass,hx] |
| split_ifs <;> simp [he] |
|
|
| omit [DecidableEq P] in |
| lemma activeMass_integrable (d : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) (x : P) (hx : p x = 0) |
| (T lam : ℝ) : Integrable (activeMass d p x T lam) := by |
| classical |
| apply (nongiantMass_integrable d hn p hp h1 x hx).mono' |
| (activeMass_measurable d p x T lam).aestronglyMeasurable |
| filter_upwards with r |
| unfold activeMass nongiantMass |
| split_ifs <;> simp_all [abs_of_nonneg (mass_nonneg hp (d.cell r x)),mass_nonneg hp] |
|
|
| lemma straddle_integrable (d : Depth P) (hn : 2 ≤ Fintype.card P) (x : P) (h H : ℝ) : |
| Integrable (straddle d x h H) := by |
| classical |
| have he : straddle d x h H = |
| (Set.Ico (h-H-d.sourceM x) (h+H-d.sourceM x)).indicator (fun _ : ℝ => (1:ℝ)) := by |
| funext r |
| simp only [straddle,d.sourceGiant_cutoff hn,not_le,Set.indicator_apply,Set.mem_Ico] |
| congr 1 |
| apply propext |
| constructor <;> rintro ⟨a,b⟩ <;> constructor <;> linarith |
| rw [he,integrable_indicator_iff measurableSet_Ico] |
| exact integrableOn_const (by rw [Real.volume_Ico]; exact ENNReal.ofReal_ne_top) |
|
|
| lemma neighborMass_integrable (d d' : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (x : P) (T : ℝ) : Integrable (neighborMass d d' p x T) := by |
| classical |
| unfold neighborMass |
| apply integrable_finsetSum |
| intro y _ |
| apply Integrable.const_mul |
| by_cases h : x ∈ (d.smallNeighbors y T).erase y |
| · simpa only [h,ite_true] using d'.integrable_outsideIndicator hn y |
| · simp only [h,ite_false] |
| exact integrable_zero _ _ _ |
|
|
| lemma neighborMass_integral (d d' : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (x : P) (T : ℝ) : |
| (∫ r, neighborMass d d' p x T r) = |
| ∑ y, p y * (if x ∈ (d.smallNeighbors y T).erase y then d'.potential y else 0) := by |
| classical |
| unfold neighborMass |
| rw [integral_finsetSum] |
| · apply Finset.sum_congr rfl |
| intro y _ |
| rw [integral_const_mul] |
| by_cases hh : x ∈ (d.smallNeighbors y T).erase y |
| · simp only [hh,ite_true,Depth.potential] |
| · simp only [hh,ite_false,integral_zero] |
| · intro y _ |
| apply Integrable.const_mul |
| by_cases hh : x ∈ (d.smallNeighbors y T).erase y |
| · simpa only [hh,ite_true] using d'.integrable_outsideIndicator hn y |
| · simp only [hh,ite_false]; exact integrable_zero _ _ _ |
|
|
| end WeakPinned.SmallFiber |
|
|
| namespace WeakPinned.SmallFiber |
| open MeasureTheory Hierarchy |
| variable {P : Type u7} [Fintype P] [DecidableEq P] |
|
|
| lemma pairMass_integrable (d : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (x : P) (hx : p x = 0) : |
| Integrable (fun r => ∑ y, p y * d.pairOverlap r x y) := by |
| apply integrable_finsetSum |
| intro y _ |
| by_cases hxy : x = y |
| · subst y; simp only [hx,zero_mul]; exact integrable_zero _ _ _ |
| · exact (d.integrable_pairOverlap hn x y hxy).const_mul _ |
|
|
| lemma integral_nongiantMass_bound (d : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) (x : P) (hx : p x = 0) : |
| (∫ r, nongiantMass d p x r) ≤ ∑ y, p y * ∫ r, d.pairOverlap r x y := by |
| calc |
| _ ≤ ∫ r : ℝ, ∑ y, p y * d.pairOverlap r x y := |
| integral_mono (nongiantMass_integrable d hn p hp h1 x hx) (pairMass_integrable d hn p x hx) |
| (fun r => nongiant_mass_bound d p hp x r) |
| _ = _ := by |
| rw [integral_finsetSum] |
| · exact Finset.sum_congr rfl (fun y _ => integral_const_mul (p y) _) |
| · intro y _ |
| by_cases hxy : x = y |
| · subst y; simp only [hx,zero_mul]; exact integrable_zero _ _ _ |
| · exact (d.integrable_pairOverlap hn x y hxy).const_mul _ |
|
|
| /-- The local small-fiber bound for two entire realized hierarchies. This |
| includes the exact signed-depth error; it will vanish at finite places |
| and have an exponentially small grid mean at archimedean places. -/ |
| lemma active_integral (d d' : Depth P) (hn : 2 ≤ Fintype.card P) |
| (p : P → ℝ) (hp : ∀ y, 0 ≤ p y) (h1 : ∑ y, p y = 1) |
| (x : P) (hx : p x = 0) (h H T lam : ℝ) |
| (hH : 0 ≤ H) (hlam : 0 ≤ lam) (hlam2 : lam ≤ 1/2) : |
| (∫ r, activeMass d p x T lam r) ≤ |
| 2*lam*(∑ y, p y * ∫ r, d'.pairOverlap r x y) + 2*lam*H + |
| (∑ y, p y * max (|d.value x y+d'.value x y-h|-H) 0) + |
| ∑ y, p y * (if x ∈ (d.smallNeighbors y T).erase y then d'.potential y else 0) := by |
| classical |
| have hshift₁ (r : ℝ) : h-r-H = (h-H)-r := by ring |
| have hshift₂ (r : ℝ) : h-r+H = (h+H)-r := by ring |
| have hi₁ : Integrable (fun r => 2*lam*nongiantMass d' p x (h-r-H)) := by |
| simp_rw [hshift₁] |
| exact ((integrable_comp_sub_left _ (h-H)).mpr (nongiantMass_integrable d' hn p hp h1 x hx)).const_mul _ |
| have hi₂ : Integrable (fun r => lam*straddle d' x h H r) := |
| (straddle_integrable d' hn x h H).const_mul _ |
| have hi₃ := (minusError_integrable d d' p x hx h H).add (plusError_integrable d d' p x hx h H) |
| have hi₄ : Integrable (fun r => neighborMass d d' p x T (h-r+H)) := by |
| simp_rw [hshift₂] |
| exact (integrable_comp_sub_left _ (h+H)).mpr (neighborMass_integrable d d' hn p x T) |
| have hb := integral_mono (activeMass_integrable d hn p hp h1 x hx T lam) |
| (((hi₁.add hi₂).add hi₃).add hi₄) (fun r => by |
| have hh := active_pointwise d d' p hp h1 x hx h H T lam r hlam hlam2 |
| dsimp only [Pi.add_apply] |
| linarith) |
| simp only [Pi.add_apply] at hb |
| have he₁ := integral_add ((hi₁.add hi₂).add hi₃) hi₄ |
| have he₂ := integral_add (hi₁.add hi₂) hi₃ |
| have he₃ := integral_add hi₁ hi₂ |
| simp only [Pi.add_apply] at he₁ he₂ he₃ |
| rw [he₁,he₂,he₃] at hb |
| rw [integral_const_mul,integral_const_mul] at hb |
| simp_rw [hshift₁,hshift₂] at hb |
| rw [integral_sub_left_eq_self,integral_sub_left_eq_self, |
| neighborMass_integral d d' hn p x T,errors_integral d d' p x hx h H hH] at hb |
| have hs : (∫ r, straddle d' x h H r) = 2*H := d'.straddle_integral hn x h H hH |
| rw [hs] at hb |
| have hng := mul_le_mul_of_nonneg_left (integral_nongiantMass_bound d' hn p hp h1 x hx) |
| (show 0 ≤ 2*lam by positivity) |
| linarith |
|
|
| /-- Exact edge law induced by fiber sampling; no independence of fiber |
| labels or levels is postulated. -/ |
| def edgeLaw {I : Type u8} [Fintype I] (w : I → ℝ) (p : I → P → ℝ) (x : I → P) (a b : P) : ℝ := |
| ∑ i, if x i = a then w i * p i b else 0 |
|
|
| lemma fiber_neighbor_bound {I : Type u9} [Fintype I] |
| (d d' : Depth P) (hn : 2 ≤ Fintype.card P) |
| (w : I → ℝ) (p : I → P → ℝ) (x : I → P) |
| (B τ : ℝ) (hB : 0 ≤ B) (hτ : 0 < τ) (hτ1 : τ ≤ 1) |
| (hdom : ∀ a b, a ≠ b → edgeLaw w p x a b ≤ B/((Fintype.card P:ℝ)*((Fintype.card P:ℝ)-1))) : |
| (∑ i, w i * ∑ y, p i y * |
| (if x i ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y then d'.potential y else 0)) ≤ |
| B*τ/Fintype.card P * ∑ y, d'.potential y := by |
| classical |
| have hn0 : 0 < (Fintype.card P:ℝ) := by exact_mod_cast (show 0 < Fintype.card P by omega) |
| have hn1 : 0 < (Fintype.card P:ℝ)-1 := by |
| have : (2:ℝ) ≤ Fintype.card P := by exact_mod_cast hn |
| linarith |
| have hid (y : P) : |
| (∑ i, w i * (p i y * (if x i ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y then d'.potential y else 0))) = |
| (∑ a ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, edgeLaw w p x a y) * d'.potential y := by |
| rw [Finset.sum_mul] |
| simp only [edgeLaw,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [← Finset.sum_mul] |
| have he : (∑ a ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, |
| if x i = a then w i*p i y else 0) = |
| if x i ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y then w i*p i y else 0 := by |
| simp [eq_comm] |
| rw [he] |
| split_ifs <;> ring |
| simp_rw [Finset.mul_sum] |
| rw [Finset.sum_comm] |
| simp_rw [hid] |
| have hb (y : P) : (∑ a ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, edgeLaw w p x a y) ≤ B*τ/Fintype.card P := by |
| calc |
| _ ≤ ((d.smallNeighbors y (τ*Fintype.card P)).erase y).card * |
| (B/((Fintype.card P:ℝ)*((Fintype.card P:ℝ)-1))) := by |
| calc |
| _ ≤ ∑ a ∈ (d.smallNeighbors y (τ*Fintype.card P)).erase y, |
| B/((Fintype.card P:ℝ)*((Fintype.card P:ℝ)-1)) := |
| Finset.sum_le_sum (fun a ha => hdom a y (Finset.ne_of_mem_erase ha)) |
| _ = _ := by simp |
| _ ≤ (τ*((Fintype.card P:ℝ)-1)) * (B/((Fintype.card P:ℝ)*((Fintype.card P:ℝ)-1))) := |
| mul_le_mul_of_nonneg_right (d.smallNeighbors_erase_bound hn y τ hτ hτ1) (by positivity) |
| _ = _ := by field_simp |
| exact Finset.sum_le_sum (fun y _ => mul_le_mul_of_nonneg_right (hb y) (d'.potential_nonneg y)) |
|
|
| end WeakPinned.SmallFiber |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
