| import OAI.Analysis.CircleDomains.Probability.ConfigurationMeasures |
| import OAI.Analysis.CircleDomains.Selection.AtomicHitTests |
|
|
| namespace OAI |
|
|
| /-! The mean measure of separated unit-square-norm configurations has atomic |
| square norm at most one. Separation makes the point assignment injective; |
| Cauchy--Schwarz then passes the finite-dimensional bound through averaging. -/ |
|
|
| open Set Function Filter MeasureTheory |
| open scoped Topology ENNReal |
|
|
| noncomputable section |
|
|
| namespace CircleDomainRigidity |
|
|
| private theorem sum_sq_fibers_le {I X : Type*} [Fintype I] [DecidableEq X] |
| (p : I → X) (hp : Injective p) (w : I → ℝ) (F : Finset X) : |
| ∑ x ∈ F, (∑ i, if p i = x then w i else 0) ^ 2 ≤ ∑ i, w i ^ 2 := by |
| classical |
| have he (x : X) : (∑ i, if p i = x then w i else 0) ^ 2 = |
| ∑ i, if p i = x then w i ^ 2 else 0 := by |
| by_cases hx : ∃ i, p i = x |
| · obtain ⟨i, hi⟩ := hx |
| have heq (j : I) : p j = x ↔ j = i := by |
| constructor |
| · intro h; exact hp (h.trans hi.symm) |
| · rintro rfl; exact hi |
| simp only [heq, Finset.sum_ite_eq', Finset.mem_univ, ite_true] |
| · have hn (i : I) : p i ≠ x := fun hi => hx ⟨i, hi⟩ |
| simp [hn] |
| simp_rw [he] |
| rw [Finset.sum_comm] |
| apply Finset.sum_le_sum |
| intro i _ |
| simp only [Finset.sum_ite_eq] |
| split |
| · exact le_rfl |
| · exact sq_nonneg _ |
|
|
| private theorem sum_sq_integrals_le_one {I T : Type*} [Fintype I] [MeasurableSpace T] |
| (P : ProbabilityMeasure T) (h : I → T → ℝ) |
| (hi : ∀ i, Integrable (h i) (P : Measure T)) |
| (hbound : ∀ t, ∑ i, h i t ^ 2 ≤ 1) : |
| ∑ i, (∫ t, h i t ∂(P : Measure T)) ^ 2 ≤ 1 := by |
| let v : I → ℝ := fun i => ∫ t, h i t ∂(P : Measure T) |
| let S := ∑ i, v i ^ 2 |
| have hS0 : 0 ≤ S := Finset.sum_nonneg fun _ _ => sq_nonneg _ |
| have hb (t : T) : ∑ i, v i * h i t ≤ Real.sqrt S := by |
| have hh : Real.sqrt (∑ i, h i t ^ 2) ≤ 1 := |
| Real.sqrt_le_iff.mpr ⟨by norm_num, by simpa using hbound t⟩ |
| exact (Real.sum_mul_le_sqrt_mul_sqrt Finset.univ v (fun i => h i t)).trans |
| (by simpa only [S, mul_one] using mul_le_mul_of_nonneg_left hh (Real.sqrt_nonneg S)) |
| have hsi : Integrable (fun t => ∑ i, v i * h i t) (P : Measure T) := |
| integrable_finsetSum _ fun i _ => (hi i).const_mul (v i) |
| have he : ∫ t, ∑ i, v i * h i t ∂(P : Measure T) = S := by |
| rw [integral_finsetSum _ (fun i _ => (hi i).const_mul (v i))] |
| simp only [integral_const_mul, S, v, sq] |
| have hle : S ≤ Real.sqrt S := by |
| calc |
| S = ∫ t, ∑ i, v i * h i t ∂(P : Measure T) := he.symm |
| _ ≤ Real.sqrt S := by |
| simpa only [integral_const, probReal_univ, one_smul] using |
| integral_mono_ae hsi (integrable_const (Real.sqrt S)) (Eventually.of_forall hb) |
| have hsq := Real.sq_sqrt hS0 |
| change S ≤ 1 |
| nlinarith [Real.sqrt_nonneg S] |
|
|
| variable {X : Type*} [MetricSpace X] [SecondCountableTopology X] |
| [MeasurableSpace X] [BorelSpace X] {n : ℕ} {r : ℝ} |
|
|
| omit [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X] in |
| theorem HitConfiguration.points_injective (hr : 0 < r) (p : HitConfiguration X n r) : |
| Injective p.val.1 := by |
| intro i j hij |
| by_contra hne |
| have h := p.property.2 i j hne |
| rw [hij, dist_self] at h |
| exact (not_le.mpr hr) h |
|
|
| theorem configurationMeasure_atom_real [DecidableEq X] (p : HitConfiguration X n r) (x : X) : |
| (configurationMeasure p {x}).toReal = |
| ∑ i, if p.val.1 i = x then (p.val.2 i : ℝ) else 0 := by |
| classical |
| simp only [configurationMeasure, Measure.coe_finsetSum, Finset.sum_apply, |
| Measure.smul_apply, smul_eq_mul, Measure.dirac_apply, Set.indicator_apply, |
| mem_singleton_iff, Pi.one_apply] |
| rw [ENNReal.toReal_sum (fun i _ => by split_ifs <;> simp)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| split_ifs <;> simp [ENNReal.toReal_ofReal (p.val.2 i).property.1] |
|
|
| theorem configurationMeasure_hasAtomicSquareBound (hr : 0 < r) |
| (p : HitConfiguration X n r) : HasAtomicSquareBound (configurationMeasure p) := by |
| classical |
| intro F |
| simp_rw [configurationMeasure_atom_real] |
| exact (sum_sq_fibers_le p.val.1 (HitConfiguration.points_injective hr p) (fun i => (p.val.2 i : ℝ)) F).trans |
| p.property.1 |
|
|
| instance (p : HitConfiguration X n r) : IsFiniteMeasure (configurationMeasure p) := |
| ⟨lt_of_le_of_lt (configurationMeasure_mass_le p) (by simp)⟩ |
|
|
| theorem meanConfigurationMeasure_atom_real |
| (P : ProbabilityMeasure (HitConfiguration X n r)) (x : X) : |
| (meanConfigurationMeasure P {x}).toReal = |
| ∫ p, (configurationMeasure p {x}).toReal ∂(P : Measure (HitConfiguration X n r)) := by |
| rw [meanConfigurationMeasure, Measure.bind_apply (measurableSet_singleton x) |
| measurable_configurationMeasure.aemeasurable] |
| exact (integral_toReal |
| ((Measure.measurable_coe (measurableSet_singleton x)).comp |
| measurable_configurationMeasure).aemeasurable |
| (Eventually.of_forall fun p => measure_lt_top (configurationMeasure p) {x})).symm |
|
|
| theorem integrable_configuration_atom |
| (P : ProbabilityMeasure (HitConfiguration X n r)) (x : X) : |
| Integrable (fun p => (configurationMeasure p {x}).toReal) |
| (P : Measure (HitConfiguration X n r)) := by |
| apply Integrable.of_bound |
| (((Measure.measurable_coe (measurableSet_singleton x)).comp |
| measurable_configurationMeasure).ennreal_toReal.aestronglyMeasurable) n |
| apply Eventually.of_forall |
| intro p |
| rw [Real.norm_eq_abs, abs_of_nonneg ENNReal.toReal_nonneg] |
| change (configurationMeasure p {x}).toReal ≤ (n : ℝ) |
| have hle : configurationMeasure p {x} ≤ n := |
| (measure_mono (subset_univ _)).trans (configurationMeasure_mass_le p) |
| simpa only [ENNReal.toReal_natCast] using ENNReal.toReal_mono (by simp) hle |
|
|
| theorem meanConfigurationMeasure_hasAtomicSquareBound (hr : 0 < r) |
| (P : ProbabilityMeasure (HitConfiguration X n r)) : |
| HasAtomicSquareBound (meanConfigurationMeasure P) := by |
| classical |
| intro F |
| let a : F → HitConfiguration X n r → ℝ := fun x p => (configurationMeasure p {x.val}).toReal |
| have hi (x : F) : Integrable (a x) (P : Measure (HitConfiguration X n r)) := |
| integrable_configuration_atom P x.val |
| have hb (p : HitConfiguration X n r) : ∑ x : F, a x p ^ 2 ≤ 1 := by |
| exact (Finset.sum_coe_sort F (fun x : X => (configurationMeasure p {x}).toReal ^ 2)).le.trans |
| (configurationMeasure_hasAtomicSquareBound hr p F) |
| have h := sum_sq_integrals_le_one P a hi hb |
| simp_rw [meanConfigurationMeasure_atom_real] |
| exact (Finset.sum_coe_sort F (fun x : X => |
| (∫ p, (configurationMeasure p {x}).toReal ∂(P : Measure (HitConfiguration X n r))) ^ 2)).symm.le.trans h |
|
|
| end CircleDomainRigidity |
|
|
| end |
|
|
| end OAI |
|
|
