| import Mathlib |
|
|
| namespace OAI |
|
|
| section |
| section |
| section |
| noncomputable section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| open Set MeasureTheory |
| open scoped BigOperators |
|
|
| namespace CannonAnnular |
|
|
| theorem weighted_open_interval_cover {ι : Type*} [Fintype ι] |
| (L U w : ι → ℝ) (a b c : ℝ) (hab : a ≤ b) |
| (hLU : ∀ i, L i ≤ U i) (hw : ∀ i, 0 ≤ w i) |
| (hcover : ∀ t ∈ Ioo a b, |
| c ≤ ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => w i) t) : |
| c * (b - a) ≤ ∑ i, w i * (U i - L i) := by |
| have hint (l u v : ℝ) : Integrable ((Icc l u).indicator (fun _ : ℝ => v)) := by |
| apply (integrable_indicator_iff measurableSet_Icc).mpr |
| exact integrableOn_const (by simp [Real.volume_Icc]) |
| have hinta : Integrable ((Ioo a b).indicator (fun _ : ℝ => c)) := by |
| apply (integrable_indicator_iff measurableSet_Ioo).mpr |
| exact integrableOn_const (by simp [Real.volume_Ioo]) |
| have hle : (Ioo a b).indicator (fun _ : ℝ => c) ≤ |
| fun t => ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => w i) t := by |
| intro t |
| by_cases ht : t ∈ Ioo a b |
| · simpa [Set.indicator_of_mem ht] using hcover t ht |
| · rw [Set.indicator_of_notMem ht] |
| exact Finset.sum_nonneg (fun i _ => Set.indicator_nonneg (fun _ _ => hw i) _) |
| have hi := integral_mono hinta |
| (integrable_finsetSum _ (fun i _ => hint (L i) (U i) (w i))) hle |
| rw [integral_finsetSum _ (fun i _ => hint (L i) (U i) (w i))] at hi |
| simpa only [integral_indicator_const _ measurableSet_Ioo, |
| integral_indicator_const _ measurableSet_Icc, Measure.real, |
| Real.volume_Ioo, Real.volume_Icc, ENNReal.toReal_ofReal (sub_nonneg.mpr hab), |
| ENNReal.toReal_ofReal (sub_nonneg.mpr (hLU _)), smul_eq_mul, mul_comm] using hi |
|
|
| theorem interval_energy_cover {ι : Type*} [Fintype ι] |
| (L U w : ι → ℝ) (a b : ℝ) (hab : a ≤ b) |
| (hLU : ∀ i, L i ≤ U i) (hw : ∀ i, 0 ≤ w i) |
| (hcover : ∀ t ∈ Ioo a b, |
| 1 ≤ ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => w i) t) : |
| (b - a)^2 ≤ (∑ i, (w i)^2) * (∑ i, (U i - L i)^2) := by |
| have h := weighted_open_interval_cover L U w a b 1 hab hLU hw hcover |
| simp only [one_mul] at h |
| exact (pow_le_pow_left₀ (sub_nonneg.mpr hab) h 2).trans |
| (Finset.sum_mul_sq_le_sq_mul_sq Finset.univ w (fun i => U i - L i)) |
|
|
| theorem overlap_energy {α β : Type*} [Fintype α] [Fintype β] [DecidableEq β] |
| (R : α → Finset β) (w : β → ℝ) (kr kc : ℕ) |
| (hrow : ∀ i, (R i).card ≤ kr) |
| (hcol : ∀ j, (Finset.univ.filter (fun i => j ∈ R i)).card ≤ kc) : |
| (∑ i, (∑ j ∈ R i, w j)^2) ≤ |
| (kr : ℝ) * kc * (∑ j, (w j)^2) := by |
| classical |
| have hrowE (i : α) : (∑ j ∈ R i, w j)^2 ≤ (kr : ℝ) * (∑ j ∈ R i, (w j)^2) := by |
| have h := Finset.sum_mul_sq_le_sq_mul_sq (R i) (fun _ => (1:ℝ)) w |
| simp only [one_mul, one_pow, Finset.sum_const, nsmul_eq_mul, mul_one] at h |
| exact h.trans (mul_le_mul_of_nonneg_right (by exact_mod_cast hrow i) |
| (Finset.sum_nonneg (fun j _ => sq_nonneg (w j)))) |
| have hswap : (∑ i, ∑ j ∈ R i, (w j)^2) = |
| ∑ j, ((Finset.univ.filter (fun i => j ∈ R i)).card : ℝ) * (w j)^2 := by |
| calc |
| _ = ∑ i, ∑ j : β, if j ∈ R i then (w j)^2 else 0 := by |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [← Finset.sum_filter] |
| simp |
| _ = ∑ j, ∑ i ∈ Finset.univ.filter (fun i => j ∈ R i), (w j)^2 := by |
| simp only [Finset.sum_filter] |
| rw [Finset.sum_comm] |
| _ = _ := by simp |
| calc |
| _ ≤ ∑ i, (kr : ℝ) * (∑ j ∈ R i, (w j)^2) := Finset.sum_le_sum (fun i _ => hrowE i) |
| _ = (kr : ℝ) * (∑ i, ∑ j ∈ R i, (w j)^2) := (Finset.mul_sum ..).symm |
| _ = (kr : ℝ) * (∑ j, ((Finset.univ.filter (fun i => j ∈ R i)).card : ℝ) * (w j)^2) := by rw [hswap] |
| _ ≤ (kr : ℝ) * (∑ j, (kc : ℝ) * (w j)^2) := by |
| apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) |
| exact Finset.sum_le_sum (fun j _ => mul_le_mul_of_nonneg_right |
| (by exact_mod_cast hcol j) (sq_nonneg (w j))) |
| _ = _ := by rw [← Finset.mul_sum]; ring |
|
|
| theorem annular_energy_transfer {α β γ : Type*} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq β] [DecidableEq γ] |
| (R : α → Finset β) (S : α → Finset γ) (ω : β → ℝ) (ρ : γ → ℝ) |
| (L U : α → ℝ) (a b : ℝ) (hab : a ≤ b) |
| (hω : ∀ j, 0 ≤ ω j) (_hρ : ∀ j, 0 ≤ ρ j) (hLU : ∀ i, L i ≤ U i) |
| (hlocal : ∀ i, U i - L i ≤ ∑ j ∈ S i, ρ j) |
| (kr kc lr lc : ℕ) |
| (hRrow : ∀ i, (R i).card ≤ kr) |
| (hRcol : ∀ j, (Finset.univ.filter (fun i => j ∈ R i)).card ≤ kc) |
| (hSrow : ∀ i, (S i).card ≤ lr) |
| (hScol : ∀ j, (Finset.univ.filter (fun i => j ∈ S i)).card ≤ lc) |
| (hcover : ∀ t ∈ Ioo a b, |
| 1 ≤ ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => ∑ j ∈ R i, ω j) t) : |
| (b-a)^2 ≤ ((kr:ℝ)*kc*lr*lc) * (∑ j, (ω j)^2) * (∑ j, (ρ j)^2) := by |
| have henergy := interval_energy_cover L U (fun i => ∑ j ∈ R i, ω j) a b hab hLU |
| (fun i => Finset.sum_nonneg (fun j _ => hω j)) hcover |
| have hωE := overlap_energy R ω kr kc hRrow hRcol |
| have hρE : (∑ i, (U i-L i)^2) ≤ (lr:ℝ)*lc*(∑ j, (ρ j)^2) := by |
| apply le_trans _ (overlap_energy S ρ lr lc hSrow hScol) |
| exact Finset.sum_le_sum (fun i _ => pow_le_pow_left₀ (sub_nonneg.mpr (hLU i)) (hlocal i) 2) |
| have hmul := mul_le_mul hωE hρE |
| (Finset.sum_nonneg (fun i _ => sq_nonneg (U i-L i))) (by positivity) |
| calc |
| _ ≤ ((kr:ℝ)*kc*(∑ j, (ω j)^2)) * ((lr:ℝ)*lc*(∑ j, (ρ j)^2)) := henergy.trans hmul |
| _ = _ := by ring |
|
|
| end CannonAnnular |
|
|
| namespace CannonAnnular |
|
|
| theorem finite_charge_cover {α β : Type*} [Fintype α] [Fintype β] |
| (A : Finset α) (B : Finset β) (R : α → Finset β) (w : β → ℝ) |
| (hw : ∀ j, 0 ≤ w j) |
| (hcharge : ∀ j ∈ B, ∃ i ∈ A, j ∈ R i) : |
| (∑ j ∈ B, w j) ≤ ∑ i ∈ A, ∑ j ∈ R i, w j := by |
| classical |
| calc |
| _ ≤ ∑ j ∈ B, ∑ i ∈ A, if j ∈ R i then w j else 0 := by |
| apply Finset.sum_le_sum |
| intro j hj |
| obtain ⟨i, hi, hij⟩ := hcharge j hj |
| have hh := Finset.single_le_sum (s := A) (f := fun i => if j ∈ R i then w j else 0) |
| (fun i _ => by split_ifs; exact hw j; exact le_rfl) hi |
| simpa only [ite_eq_left hij] using hh |
| _ = ∑ i ∈ A, ∑ j ∈ B, if j ∈ R i then w j else 0 := Finset.sum_comm |
| _ ≤ _ := by |
| apply Finset.sum_le_sum |
| intro i _ |
| rw [← Finset.sum_filter] |
| apply Finset.sum_le_sum_of_subset_of_nonneg |
| · intro j hj |
| exact (Finset.mem_filter.mp hj).2 |
| · exact fun j _ _ => hw j |
|
|
| theorem interval_cover_of_charging {α β : Type*} [Fintype α] [Fintype β] |
| (R : α → Finset β) (w : β → ℝ) (L U : α → ℝ) |
| (hw : ∀ j, 0 ≤ w j) (t : ℝ) (B : Finset β) |
| (hB : 1 ≤ ∑ j ∈ B, w j) |
| (hcharge : ∀ j ∈ B, ∃ i, t ∈ Icc (L i) (U i) ∧ j ∈ R i) : |
| 1 ≤ ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => ∑ j ∈ R i, w j) t := by |
| classical |
| let A := Finset.univ.filter (fun i => t ∈ Icc (L i) (U i)) |
| have hh := finite_charge_cover A B R w hw (by |
| intro j hj |
| obtain ⟨i, hit, hij⟩ := hcharge j hj |
| exact ⟨i, Finset.mem_filter.mpr ⟨Finset.mem_univ _, hit⟩, hij⟩) |
| apply hB.trans (hh.trans_eq _) |
| simp only [A, Finset.sum_filter] |
| apply Finset.sum_congr rfl |
| intro i _ |
| by_cases hi : t ∈ Icc (L i) (U i) <;> simp [hi] |
|
|
| end CannonAnnular |
|
|
| namespace CannonAnnular |
|
|
| theorem annular_net_charge {X Y α : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] |
| (q : α → X) (h : X → Y) (f : X → ℝ) (L U : α → ℝ) |
| (x y z : X) (ξ : Y) (R r C t : ℝ) |
| (hR : 0 < R) (hr : 0 ≤ r) (hrR : r ≤ R / 2) (hC : 0 ≤ C) |
| (hy : R ≤ dist y x ∧ dist y x ≤ 2*R) |
| (hnet : ∃ i, dist (q i) y ≤ r) |
| (hzoom : ∀ u v, dist u x ≤ 3*R → dist v x ≤ 3*R → |
| dist (h u) (h v) ≤ C / R * dist u v) |
| (hξ : dist ξ (h y) ≤ 2 * (r / R)) |
| (hz : dist z y ≤ r / 4) (hf : f z = t) |
| (hrange : ∀ i z, dist z (q i) ≤ 2*r → f z ∈ Icc (L i) (U i)) : |
| ∃ i, R/2 ≤ dist (q i) x ∧ dist (q i) x ≤ 3*R ∧ |
| t ∈ Icc (L i) (U i) ∧ dist ξ (h (q i)) ≤ (C+2)*(r/R) := by |
| obtain ⟨i, hi⟩ := hnet |
| have hqu : dist (q i) x ≤ 3*R := (dist_triangle (q i) y x).trans (by linarith [hy.2]) |
| have hql : R/2 ≤ dist (q i) x := by |
| have hh := dist_triangle y (q i) x |
| rw [dist_comm y (q i)] at hh |
| linarith [hy.1] |
| refine ⟨i, hql, hqu, ?_, ?_⟩ |
| · rw [← hf] |
| apply hrange |
| have hh := dist_triangle z y (q i) |
| rw [dist_comm y (q i)] at hh |
| linarith |
| · have hqy : dist (h (q i)) (h y) ≤ C/R*r := by |
| exact (hzoom _ _ hqu (by linarith [hy.2])).trans |
| (mul_le_mul_of_nonneg_left hi (div_nonneg hC hR.le)) |
| have hh := dist_triangle ξ (h y) (h (q i)) |
| rw [dist_comm (h y) (h (q i))] at hh |
| calc |
| _ ≤ 2*(r/R) + C/R*r := hh.trans (add_le_add hξ hqy) |
| _ = _ := by ring |
|
|
| theorem charged_center_in_annulus {X : Type*} [PseudoMetricSpace X] |
| (x q p : X) (R d : ℝ) (hR : 0 ≤ R) |
| (hq : R/2 ≤ dist q x ∧ dist q x ≤ 3*R) |
| (hpq : dist p q ≤ d) (hd : d ≤ R/4) : |
| R/4 ≤ dist p x ∧ dist p x ≤ 4*R := by |
| constructor |
| · have hh := dist_triangle q p x |
| rw [dist_comm q p] at hh |
| linarith [hq.1] |
| · have hh := dist_triangle p q x |
| linarith [hq.2] |
|
|
| end CannonAnnular |
|
|
| end |
|
|
| namespace CannonCapacity |
|
|
| open Finset Set |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| theorem bin_interval_detection {ι β : Type*} [Fintype ι] [Fintype β] |
| (near : β → ι → Prop) (L U v t : ι → ℝ) (a b B : ℝ) |
| (hab : a < b) (hLU : ∀ i, L i ≤ U i) (hv : ∀ i, 0 ≤ v i) |
| (hlen : ∀ i, U i-L i = (b-a)*t i) |
| (hmult : ∀ i, ((univ.filter (fun z : β => near z i)).card : ℝ) ≤ B) |
| (hcover : ∀ z s, s ∈ Ioo a b → |
| 1 ≤ ∑ i, (Icc (L i) (U i)).indicator (fun _ : ℝ => if near z i then v i else 0) s) : |
| (Fintype.card β : ℝ) ≤ B * ∑ i, v i*t i := by |
| classical |
| have ht : ∀ i, 0 ≤ t i := by |
| intro i |
| have := sub_nonneg.mpr (hLU i) |
| rw [hlen] at this |
| exact nonneg_of_mul_nonneg_right this (sub_pos.mpr hab) |
| have hb (z : β) := CannonAnnular.weighted_open_interval_cover L U |
| (fun i => if near z i then v i else 0) a b 1 hab.le hLU |
| (fun i => by split_ifs; exact hv i; exact le_rfl) (hcover z) |
| have hh := Finset.sum_le_sum (s := univ) (fun z _ => hb z) |
| simp only [one_mul, sum_const, card_univ, nsmul_eq_mul] at hh |
| have hr : ∑ z : β, ∑ i : ι, (if near z i then v i else 0)*(U i-L i) ≤ |
| (b-a)*(B * ∑ i, v i*t i) := by |
| rw [sum_comm] |
| calc |
| _ = ∑ i : ι, ((univ.filter (fun z : β => near z i)).card : ℝ)*v i*((b-a)*t i) := by |
| apply sum_congr rfl |
| intro i _ |
| rw [← sum_mul,hlen,← sum_filter] |
| simp |
| _ ≤ ∑ i : ι, B*v i*((b-a)*t i) := by |
| apply sum_le_sum |
| intro i _ |
| exact mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_right (hmult i) (hv i)) (mul_nonneg (sub_pos.mpr hab).le (ht i)) |
| _ = _ := by simp_rw [show ∀ i, B*v i*((b-a)*t i) = (b-a)*B*(v i*t i) by intro i; ring] |
| rw [← mul_sum]; ring |
| have hfinal := hh.trans hr |
| rw [mul_comm (Fintype.card β : ℝ)] at hfinal |
| exact (mul_le_mul_iff_right₀ (sub_pos.mpr hab)).mp hfinal |
|
|
| theorem mixed_capacity_of_detection {ι : Type*} [Fintype ι] |
| (t σ : ι → ℝ) (ht : ∀ i, 0 ≤ t i) (hσ : ∀ i, 0 ≤ σ i) |
| {L Q C B E bins : ℝ} (hL : 0 < L) (hQ : 0 < Q) (_hC : 0 ≤ C) |
| (hB : 0 < B) (hE : 0 ≤ E) (hb : 0 ≤ bins) |
| (henergy : ∑ i, (σ i)^2 ≤ E) |
| (hlarge : 2*B*C ≤ L*bins) |
| (hsmall : 4*B^2*E*C < Q*bins^2) |
| (hdetect : bins ≤ B * ∑ i, (if L ≤ Q*t i then 1 else σ i)*t i) : |
| C ≤ ∑ i, min (L*t i) (Q*(t i)^2) := by |
| classical |
| let large := univ.filter (fun i => L ≤ Q*t i) |
| let small := univ.filter (fun i => ¬ L ≤ Q*t i) |
| have hnon : ∀ i, 0 ≤ min (L*t i) (Q*(t i)^2) := |
| fun i => le_min (mul_nonneg hL.le (ht i)) (mul_nonneg hQ.le (sq_nonneg _)) |
| by_contra hn |
| have hcap : ∑ i, min (L*t i) (Q*(t i)^2) < C := lt_of_not_ge hn |
| have hla : L * (∑ i ∈ large, t i) ≤ C := by |
| calc |
| _ = ∑ i ∈ large, min (L*t i) (Q*(t i)^2) := by |
| rw [mul_sum] |
| apply sum_congr rfl |
| intro i hi |
| have hh := (mem_filter.mp hi).2 |
| rw [min_eq_left (by nlinarith [mul_le_mul_of_nonneg_right hh (ht i)])] |
| _ ≤ ∑ i, min (L*t i) (Q*(t i)^2) := |
| sum_le_sum_of_subset_of_nonneg (filter_subset _ _) (fun i _ _ => hnon i) |
| _ ≤ C := hcap.le |
| have hsm : Q * (∑ i ∈ small, (t i)^2) ≤ C := by |
| calc |
| _ = ∑ i ∈ small, min (L*t i) (Q*(t i)^2) := by |
| rw [mul_sum] |
| apply sum_congr rfl |
| intro i hi |
| have hh := le_of_not_ge (mem_filter.mp hi).2 |
| rw [min_eq_right (by nlinarith [mul_le_mul_of_nonneg_right hh (ht i)])] |
| _ ≤ ∑ i, min (L*t i) (Q*(t i)^2) := |
| sum_le_sum_of_subset_of_nonneg (filter_subset _ _) (fun i _ _ => hnon i) |
| _ ≤ C := hcap.le |
| have hde : bins ≤ B*((∑ i ∈ large, t i) + ∑ i ∈ small, σ i*t i) := by |
| convert hdetect using 1 |
| congr 1 |
| simp only [large,small,sum_filter,← sum_add_distrib] |
| apply sum_congr rfl |
| intro i _ |
| split_ifs <;> simp_all |
| have hmass : bins ≤ 2*B*(∑ i ∈ small, σ i*t i) := by |
| nlinarith |
| have hCS := sum_mul_sq_le_sq_mul_sq small σ t |
| have hsumσ : ∑ i ∈ small, (σ i)^2 ≤ E := |
| (sum_le_sum_of_subset_of_nonneg (filter_subset _ _) (fun i _ _ => sq_nonneg _)).trans henergy |
| have hsmt : 0 ≤ ∑ i ∈ small, (t i)^2 := sum_nonneg (fun _ _ => sq_nonneg _) |
| have hsms : 0 ≤ ∑ i ∈ small, σ i*t i := sum_nonneg (fun i _ => mul_nonneg (hσ i) (ht i)) |
| have hsquare : bins^2 ≤ 4*B^2*(∑ i ∈ small, σ i*t i)^2 := by |
| nlinarith [sq_le_sq₀ hb (mul_nonneg (by positivity) hsms) |>.mpr hmass] |
| have hcs' : (∑ i ∈ small, σ i*t i)^2 ≤ E*(∑ i ∈ small, (t i)^2) := |
| hCS.trans (mul_le_mul_of_nonneg_right hsumσ hsmt) |
| have hbound : Q*bins^2 ≤ 4*B^2*E*C := by |
| calc |
| _ ≤ Q*(4*B^2*(∑ i ∈ small, σ i*t i)^2) := mul_le_mul_of_nonneg_left hsquare hQ.le |
| _ ≤ Q*(4*B^2*(E*(∑ i ∈ small, (t i)^2))) := by gcongr |
| _ = (4*B^2*E)*(Q*(∑ i ∈ small, (t i)^2)) := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left hsm (by positivity) |
| exact (not_lt_of_ge hbound) hsmall |
| |
| end CannonCapacity |
| |
| end |
| |
| section |
| |
| open Finset |
| |
| namespace CannonCapacity |
| |
| attribute [local instance] Classical.propDecidable |
| |
| theorem weighted_separated_subset {ι : Type*} (S : Finset ι) (rel : ι → ι → Prop) |
| (hself : ∀ i, rel i i) (hsymm : ∀ i j, rel i j → rel j i) |
| (w : ι → ℝ) (hw : ∀ i ∈ S, 0 ≤ w i) (N : ℕ) |
| (hN : ∀ i ∈ S, (S.filter (rel i)).card ≤ N) : |
| ∃ T ⊆ S, (∀ i ∈ T, ∀ j ∈ T, i ≠ j → ¬ rel i j) ∧ |
| (∑ i ∈ S, w i) ≤ (N : ℝ) * ∑ i ∈ T, w i := by |
| classical |
| induction S using Finset.strongInductionOn with |
| | _ S ih => |
| by_cases hS : S.Nonempty |
| · obtain ⟨i,hi,hmax⟩ := S.exists_max_image w hS |
| let U := S.filter (fun j => ¬ rel i j) |
| have hUS : U ⊆ S := filter_subset _ _ |
| have hiU : i ∉ U := by simp [U,hself] |
| have hss : U ⊂ S := by |
| refine ⟨hUS,?_⟩ |
| intro hh |
| exact hiU (hh hi) |
| obtain ⟨T,hTU,hsep,hbound⟩ := ih U hss |
| (fun j hj => hw j (hUS hj)) (by |
| intro j hj |
| exact (Finset.card_le_card (Finset.filter_subset_filter _ hUS)).trans (hN j (hUS hj))) |
| have hiT : i ∉ T := fun h => hiU (hTU h) |
| refine ⟨insert i T,Finset.insert_subset_iff.mpr ⟨hi,hTU.trans hUS⟩,?_,?_⟩ |
| · intro j hj k hk hjk |
| rcases mem_insert.mp hj with rfl | hjT |
| · rcases mem_insert.mp hk with rfl | hk |
| · exact fun _ => hjk rfl |
| · exact (mem_filter.mp (hTU hk)).2 |
| · rcases mem_insert.mp hk with rfl | hk |
| · exact fun h => (mem_filter.mp (hTU hjT)).2 (hsymm _ _ h) |
| · exact hsep j hjT k hk hjk |
| · have hnear : ∑ j ∈ S.filter (rel i), w j ≤ (N : ℝ)*w i := by |
| calc |
| _ ≤ ∑ j ∈ S.filter (rel i), w i := by |
| exact Finset.sum_le_sum (fun j hj => hmax j (mem_filter.mp hj).1) |
| _ = ((S.filter (rel i)).card : ℝ)*w i := by simp |
| _ ≤ _ := mul_le_mul_of_nonneg_right (by exact_mod_cast hN i hi) (hw i hi) |
| have hsplit : (∑ j ∈ S, w j) = |
| (∑ j ∈ S.filter (rel i), w j) + ∑ j ∈ U, w j := by |
| symm |
| exact Finset.sum_filter_add_sum_filter_not S (rel i) w |
| rw [hsplit,Finset.sum_insert hiT] |
| nlinarith |
| · refine ⟨∅,empty_subset _,by simp,?_⟩ |
| simp [Finset.not_nonempty_iff_eq_empty.mp hS] |
| |
| end CannonCapacity |
| |
| end |
| |
| namespace CannonCapacity |
| |
| open Set Metric Finset |
| |
| attribute [local instance] Classical.propDecidable |
| |
| def clip (a b x : ℝ) : ℝ := max a (min b x) |
| |
| lemma clip_mono (a b : ℝ) : Monotone (clip a b) := by |
| intro x y hxy |
| exact max_le_max le_rfl (min_le_min le_rfl hxy) |
| |
| lemma mem_clipped_iff {a b l u t : ℝ} (ht : t ∈ Ioo a b) : |
| t ∈ Icc (clip a b l) (clip a b u) ↔ t ∈ Icc l u := by |
| simp only [Set.mem_Icc,clip] |
| constructor |
| · rintro ⟨hl,hu⟩ |
| constructor |
| · by_contra hh |
| have hh' : t < l := lt_of_not_ge hh |
| have : t < min b l := lt_min ht.2 hh' |
| exact (not_lt_of_ge ((le_max_right _ _).trans hl)) this |
| · by_contra hh |
| have hh' : u < t := lt_of_not_ge hh |
| have : max a (min b u) < t := max_lt ht.1 (lt_of_le_of_lt (min_le_right _ _) hh') |
| exact (not_lt_of_ge hu) this |
| · rintro ⟨hl,hu⟩ |
| exact ⟨max_le ht.1.le ((min_le_right _ _).trans hl), |
| (le_min ht.2.le hu).trans (le_max_right _ _)⟩ |
| |
| lemma clip_difference {a b l u : ℝ} (hab : a ≤ b) (hlu : l ≤ u) : |
| clip a b u-clip a b l = max 0 (min b u-max a l) := by |
| unfold clip |
| rcases le_total l a with hla | hal |
| · rw [min_eq_right (hla.trans hab),max_eq_left hla] |
| rw [← max_sub_sub_right] |
| simp only [sub_self,max_comm] |
| · by_cases hlb : l ≤ b |
| · rw [min_eq_right hlb,max_eq_right hal] |
| have hmin : l ≤ min b u := le_min hlb hlu |
| rw [max_eq_right (hal.trans hmin),max_eq_right (sub_nonneg.mpr hmin)] |
| · have hbl := le_of_not_ge hlb |
| simp only [min_eq_left (hbl.trans hlu),min_eq_left hbl,max_eq_right hab,sub_self, |
| max_eq_right hal] |
| exact (max_eq_left (by linarith)).symm |
| |
| theorem clipped_bin_detection {ι β : Type*} [Fintype ι] [Fintype β] |
| (lo hi t σ : ι → ℝ) (large : ι → Prop) (near : β → ι → Prop) |
| (a b B : ℝ) (hab : a < b) (hlohi : ∀ i, lo i ≤ hi i) |
| (hlen : ∀ i, clip a b (hi i)-clip a b (lo i) = (b-a)*t i) |
| (hσ : ∀ i, 0 ≤ σ i) |
| (hmult : ∀ i, ((univ.filter (fun z => near z i)).card : ℝ) ≤ B) |
| (hunmarked : ∀ z s, s ∈ Ioo a b → |
| (∀ i, large i → near z i → s ∈ Icc (lo i) (hi i) → False) → |
| 1 ≤ ∑ i, (Icc (lo i) (hi i)).indicator |
| (fun _ : ℝ => if near z i ∧ ¬large i then σ i else 0) s) : |
| (Fintype.card β : ℝ) ≤ B * ∑ i, (if large i then 1 else σ i)*t i := by |
| apply bin_interval_detection near (fun i => clip a b (lo i)) |
| (fun i => clip a b (hi i)) (fun i => if large i then 1 else σ i) t |
| a b B hab (fun i => clip_mono a b (hlohi i)) |
| (fun i => by split_ifs; norm_num; exact hσ i) hlen hmult |
| intro z s hs |
| by_cases hm : ∃ i, large i ∧ near z i ∧ s ∈ Icc (lo i) (hi i) |
| · obtain ⟨i,hiL,hiN,hit⟩ := hm |
| calc |
| 1 = (Icc (clip a b (lo i)) (clip a b (hi i))).indicator |
| (fun _ : ℝ => if near z i then if large i then 1 else σ i else 0) s := by |
| rw [indicator_of_mem ((mem_clipped_iff hs).mpr hit),ite_eq_left hiN,ite_eq_left hiL] |
| _ ≤ ∑ j, (Icc (clip a b (lo j)) (clip a b (hi j))).indicator |
| (fun _ : ℝ => if near z j then if large j then 1 else σ j else 0) s := by |
| apply single_le_sum _ (mem_univ i) |
| intro j _ |
| apply Set.indicator_nonneg |
| intro _ _ |
| split_ifs; norm_num; exact hσ j; exact le_rfl |
| · apply (hunmarked z s hs (by simpa only [not_exists,not_and] using hm)).trans |
| apply sum_le_sum |
| intro i _ |
| by_cases hit : s ∈ Icc (lo i) (hi i) |
| · rw [indicator_of_mem hit,indicator_of_mem ((mem_clipped_iff hs).mpr hit)] |
| by_cases hn : near z i <;> by_cases hl : large i <;> simp [hn,hl] |
| · rw [indicator_of_notMem hit,indicator_of_notMem (fun hh => hit ((mem_clipped_iff hs).mp hh))] |
| |
| theorem separated_capacity_of_detection {X : Type*} [MetricSpace X] |
| {ι β : Type*} [Fintype ι] [Fintype β] |
| (q : ι → X) (lo hi t σ : ι → ℝ) (near : β → ι → Prop) |
| (a b B L Q E H r : ℝ) (N : ℕ) (hab : a < b) |
| (hlohi : ∀ i, lo i ≤ hi i) (ht : ∀ i, 0 ≤ t i) |
| (hlen : ∀ i, clip a b (hi i)-clip a b (lo i) = (b-a)*t i) |
| (hσ : ∀ i, 0 ≤ σ i) (hL : 0 < L) (hQ : 0 < Q) (hB : 0 < B) (hE : 0 ≤ E) |
| (hHr : 0 ≤ H*r) (hN : 0 < N) |
| (hdegree : ∀ i, (univ.filter (fun j => dist (q i) (q j) ≤ H*r)).card ≤ N) |
| (hmult : ∀ i, ((univ.filter (fun z => near z i)).card : ℝ) ≤ B) |
| (henergy : ∑ i, (σ i)^2 ≤ E) |
| (hlarge : 2*B*N ≤ L*Fintype.card β) |
| (hsmall : 4*B^2*E*N < Q*(Fintype.card β : ℝ)^2) |
| (hunmarked : ∀ z s, s ∈ Ioo a b → |
| (∀ i, L ≤ Q*t i → near z i → s ∈ Icc (lo i) (hi i) → False) → |
| 1 ≤ ∑ i, (Icc (lo i) (hi i)).indicator |
| (fun _ : ℝ => if near z i ∧ ¬L ≤ Q*t i then σ i else 0) s) : |
| ∃ S : Finset ι, (∀ i ∈ S, ∀ j ∈ S, i ≠ j → H*r < dist (q i) (q j)) ∧ |
| 1 ≤ ∑ i ∈ S, min (L*t i) (Q*(t i)^2) := by |
| have hdetect := clipped_bin_detection lo hi t σ (fun i => L ≤ Q*t i) near a b B |
| hab hlohi hlen hσ hmult hunmarked |
| have hcap := mixed_capacity_of_detection t σ ht hσ hL hQ (by positivity : (0:ℝ) ≤ N) |
| hB hE (by positivity) henergy hlarge hsmall hdetect |
| obtain ⟨S,hS,hsep,hbound⟩ := weighted_separated_subset univ |
| (fun i j => dist (q i) (q j) ≤ H*r) (by simpa using fun _i : ι => hHr) |
| (fun i j h => by simpa only [dist_comm] using h) |
| (fun i => min (L*t i) (Q*(t i)^2)) |
| (fun i _ => le_min (mul_nonneg hL.le (ht i)) (mul_nonneg hQ.le (sq_nonneg _))) N |
| (fun i _ => hdegree i) |
| refine ⟨S,fun i hi j hj hij => lt_of_not_ge (hsep i hi j hj hij),?_⟩ |
| have hN' : (0:ℝ) < N := by exact_mod_cast hN |
| nlinarith [hcap.trans hbound] |
|
|
| end CannonCapacity |
|
|
| end |
|
|
| section |
|
|
| section |
|
|
| open Set MeasureTheory |
| open scoped BigOperators |
| open Set unitInterval |
|
|
| namespace CannonAnnular |
|
|
| theorem radial_subinterval (g : I → ℝ) (hg : Continuous g) |
| (r s : ℝ) (hrs : r < s) (hzero : g 0 ≤ r) (hone : s ≤ g 1) : |
| ∃ a b : I, a < b ∧ g a = r ∧ g b = s ∧ |
| ∀ t ∈ Icc a b, g t ∈ Icc r s := by |
| have hnon : (g ⁻¹' {s}).Nonempty := by |
| obtain ⟨t, _, ht⟩ := intermediate_value_Icc (show (0:I) ≤ 1 from zero_le) |
| hg.continuousOn ⟨hzero.trans hrs.le, hone⟩ |
| exact ⟨t, ht⟩ |
| have hc : IsCompact (g ⁻¹' {s}) := (isClosed_singleton.preimage hg).isCompact |
| obtain ⟨b, hb, hbmin⟩ := hc.exists_isMinOn hnon continuous_id.continuousOn |
| have hgb : g b = s := hb |
| have hnonr : (Icc (0:I) b ∩ g ⁻¹' {r}).Nonempty := by |
| obtain ⟨t, ht, htr⟩ := intermediate_value_Icc (show (0:I) ≤ b from zero_le) hg.continuousOn |
| ⟨hzero, hgb ▸ hrs.le⟩ |
| exact ⟨t, ht, htr⟩ |
| have hcr : IsCompact (Icc (0:I) b ∩ g ⁻¹' {r}) := |
| isCompact_Icc.inter_right (isClosed_singleton.preimage hg) |
| obtain ⟨a, ha, hamax⟩ := hcr.exists_isMaxOn hnonr continuous_id.continuousOn |
| have hga : g a = r := ha.2 |
| have hab : a < b := lt_of_le_of_ne ha.1.2 (by intro he; rw [he, hgb] at hga; exact hrs.ne hga.symm) |
| refine ⟨a, b, hab, hga, hgb, ?_⟩ |
| intro t ht |
| constructor |
| · by_contra hn |
| have hlt : g t < r := lt_of_not_ge hn |
| obtain ⟨z, hz, hzr⟩ := intermediate_value_Icc ht.2 hg.continuousOn |
| ⟨hlt.le, hgb ▸ hrs.le⟩ |
| have hza : z ≤ a := hamax ⟨⟨zero_le, hz.2⟩, hzr⟩ |
| have htz : t < z := lt_of_le_of_ne hz.1 (by intro he; rw [← he] at hzr; exact hlt.ne hzr) |
| exact (not_lt_of_ge (hza.trans ht.1)) htz |
| · by_contra hn |
| have hlt : s < g t := lt_of_not_ge hn |
| obtain ⟨z, hz, hzs⟩ := intermediate_value_Icc (show (0:I) ≤ t from zero_le) hg.continuousOn |
| ⟨hzero.trans hrs.le, hlt.le⟩ |
| have hbz : b ≤ z := hbmin hzs |
| have hzt : z < t := lt_of_le_of_ne hz.2 (by intro he; rw [he] at hzs; exact hlt.ne' hzs) |
| exact (not_lt_of_ge (ht.2.trans hbz)) hzt |
| |
| end CannonAnnular |
| |
| namespace CannonAnnular |
| |
| theorem radial_subpath {X : Type*} [PseudoMetricSpace X] (o x y : X) |
| (p : Path x y) (r s : ℝ) (hrs : r < s) |
| (hx : dist x o ≤ r) (hy : s ≤ dist y o) : |
| ∃ u v : X, ∃ q : Path u v, |
| Set.range q ⊆ Set.range p ∧ dist u o = r ∧ dist v o = s ∧ |
| s-r ≤ dist u v ∧ ∀ t, dist (q t) o ∈ Icc r s := by |
| obtain ⟨a, b, hab, ha, hb, hbetween⟩ := radial_subinterval |
| (fun t => dist (p t) o) (p.continuous.dist continuous_const) r s hrs |
| (by simpa using hx) (by simpa using hy) |
| refine ⟨p a, p b, p.subpath a b, ?_, ha, hb, ?_, ?_⟩ |
| · rw [Path.range_subpath_of_le _ _ _ hab.le] |
| exact Set.image_subset_range _ _ |
| · have hh := dist_triangle (p b) (p a) o |
| rw [dist_comm (p b) (p a), ha, hb] at hh |
| linarith |
| · intro t |
| have ht : (p.subpath a b) t ∈ Set.range (p.subpath a b) := Set.mem_range_self _ |
| rw [Path.range_subpath_of_le _ _ _ hab.le] at ht |
| obtain ⟨z, hz, hzt⟩ := ht |
| rw [← hzt] |
| exact hbetween z hz |
| |
| theorem continuum_neighborhood_path {X : Type*} [TopologicalSpace X] |
| [LocallyPathConnectedSpace X] {K V : Set X} (hK : IsPreconnected K) |
| (hV : IsOpen V) (hKV : K ⊆ V) {x y : X} (hx : x ∈ K) (hy : y ∈ K) : |
| JoinedIn V x y := by |
| let : PreconnectedSpace K := Subtype.preconnectedSpace hK |
| let : LocallyPathConnectedSpace V := hV.locallyPathConnectedSpace |
| let f : K → V := fun z => ⟨z.val, hKV z.property⟩ |
| have hf : Continuous f := continuous_subtype_val.subtype_mk _ |
| have hconn : IsPreconnected (Set.range f) := isPreconnected_range hf |
| have hmem : f ⟨y,hy⟩ ∈ connectedComponent (f ⟨x,hx⟩) := |
| hconn.subset_connectedComponent ⟨⟨x,hx⟩, rfl⟩ ⟨⟨y,hy⟩, rfl⟩ |
| rw [← pathComponent_eq_connectedComponent] at hmem |
| obtain ⟨p⟩ := hmem |
| exact ⟨p.map continuous_subtype_val, fun t => (p t).property⟩ |
| |
| theorem annular_path_near_continuum {X : Type*} [PseudoMetricSpace X] |
| [LocallyPathConnectedSpace X] (o : X) (r s : ℝ) (hrs : r < s) |
| (K V : Set X) (hK : IsPreconnected K) (hV : IsOpen V) (hKV : K ⊆ V) |
| {x y : X} (hx : x ∈ K) (hy : y ∈ K) |
| (hxr : dist x o ≤ r) (hys : s ≤ dist y o) : |
| ∃ u v : X, ∃ q : Path u v, |
| Set.range q ⊆ V ∧ dist u o = r ∧ dist v o = s ∧ |
| s-r ≤ dist u v ∧ ∀ t, dist (q t) o ∈ Icc r s := by |
| obtain ⟨p, hp⟩ := continuum_neighborhood_path hK hV hKV hx hy |
| obtain ⟨u, v, q, hqp, hu, hv, huv, hq⟩ := radial_subpath o x y p r s hrs hxr hys |
| refine ⟨u, v, q, ?_, hu, hv, huv, hq⟩ |
| rintro z hz |
| obtain ⟨t, rfl⟩ := hqp hz |
| exact hp t |
| |
| end CannonAnnular |
| |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| |
| end OAI |
| |
