| import OAI.Analysis.CircleDomains.Sobolev.BoundedUpperIntegral |
| import OAI.Analysis.CircleDomains.Selection.FiniteConvexSplit |
| import Mathlib.MeasureTheory.Measure.Prokhorov |
|
|
| namespace OAI |
|
|
| /-! A finite mixture uniformly controls all compact test configurations if every |
| probability distribution on configurations admits a good candidate. This is the |
| finite splitting step of the manuscript's fusion argument. -/ |
|
|
| open Set MeasureTheory |
| open scoped Topology ENNReal |
|
|
| noncomputable section |
|
|
| namespace CircleDomainRigidity |
|
|
| def probabilityConvexCombination {T : Type*} [MeasurableSpace T] |
| (μ ν : ProbabilityMeasure T) (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) |
| (hab : a + b = 1) : ProbabilityMeasure T := |
| ⟨ENNReal.ofReal a • (μ : Measure T) + ENNReal.ofReal b • (ν : Measure T), by |
| constructor |
| simp only [Measure.add_apply, Measure.smul_apply, measure_univ, smul_eq_mul, mul_one] |
| rw [← ENNReal.ofReal_add ha hb, hab, ENNReal.ofReal_one]⟩ |
|
|
| theorem integral_probabilityConvexCombination {T : Type*} [MeasurableSpace T] |
| (μ ν : ProbabilityMeasure T) (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) |
| (hab : a + b = 1) {f : T → ℝ} |
| (hμ : Integrable f (μ : Measure T)) (hν : Integrable f (ν : Measure T)) : |
| ∫ t, f t ∂(probabilityConvexCombination μ ν a b ha hb hab : Measure T) = |
| a * (∫ t, f t ∂(μ : Measure T)) + b * ∫ t, f t ∂(ν : Measure T) := by |
| change ∫ t, f t ∂(ENNReal.ofReal a • (μ : Measure T) + |
| ENNReal.ofReal b • (ν : Measure T)) = _ |
| rw [integral_add_measure (hμ.smul_measure ENNReal.ofReal_ne_top) |
| (hν.smul_measure ENNReal.ofReal_ne_top), integral_smul_measure, integral_smul_measure] |
| simp only [ENNReal.toReal_ofReal ha, ENNReal.toReal_ofReal hb, smul_eq_mul] |
|
|
| theorem convex_integral_vectors {I T : Type*} [MeasurableSpace T] |
| (f : I → T → ℝ) (hf : ∀ i (μ : ProbabilityMeasure T), Integrable (f i) (μ : Measure T)) : |
| Convex ℝ (Set.range (fun μ : ProbabilityMeasure T => fun i => ∫ t, f i t ∂(μ : Measure T))) := by |
| rintro _ ⟨μ, rfl⟩ _ ⟨ν, rfl⟩ a b ha hb hab |
| refine ⟨probabilityConvexCombination μ ν a b ha hb hab, ?_⟩ |
| funext i |
| exact integral_probabilityConvexCombination μ ν a b ha hb hab (hf i μ) (hf i ν) |
|
|
| theorem exists_finite_compact_law_split |
| {T Z : Type*} [MetricSpace T] [CompactSpace T] [Nonempty T] |
| [SecondCountableTopology T] [MeasurableSpace T] [BorelSpace T] |
| (f : Z → T → ℝ) (A : Set Z) |
| (hf : ∀ z ∈ A, UpperSemicontinuous (f z)) |
| (hf0 : ∀ z ∈ A, ∀ t, 0 ≤ f z t) |
| {M : ℝ} (hM : 0 < M) (hfM : ∀ z ∈ A, ∀ t, f z t ≤ M) |
| {b ε : ℝ} (hε : 0 < ε) |
| (htest : ∀ μ : ProbabilityMeasure T, ∃ z ∈ A, ∫ t, f z t ∂(μ : Measure T) ≤ b) : |
| ∃ (n : ℕ) (z : Fin n → Z) (w : Fin n → ℝ), |
| (∀ i, z i ∈ A) ∧ (∀ i, 0 ≤ w i) ∧ (∑ i, w i) = 1 ∧ |
| ∀ t, ∑ i, w i * f (z i) t ≤ b + ε := by |
| classical |
| let U : A → Set (ProbabilityMeasure T) := fun z => |
| {μ | (∫ t, f z.val t ∂(μ : Measure T)) < b + ε} |
| have hU (z : A) : IsOpen (U z) := |
| (upperSemicontinuous_integral_bounded (hf z.val z.property) |
| (hf0 z.val z.property) hM (hfM z.val z.property)).isOpen_preimage _ |
| have hcover : (univ : Set (ProbabilityMeasure T)) ⊆ ⋃ z : A, U z := by |
| intro μ _ |
| obtain ⟨z, hz, hzt⟩ := htest μ |
| exact mem_iUnion.mpr ⟨⟨z, hz⟩, lt_of_le_of_lt hzt (by linarith)⟩ |
| obtain ⟨F, hF⟩ := isCompact_univ.elim_finite_subcover U hU hcover |
| have hFne : F.Nonempty := by |
| by_contra h |
| have hm := hF (mem_univ (diracProba (Classical.arbitrary T))) |
| simp [Finset.not_nonempty_iff_eq_empty.mp h] at hm |
| let I := {z : A // z ∈ F} |
| let : Fintype I := inferInstanceAs (Fintype F) |
| let : Nonempty I := ⟨⟨hFne.choose, hFne.choose_spec⟩⟩ |
| let g : I → T → ℝ := fun i => f i.val.val |
| have hg (i : I) (μ : ProbabilityMeasure T) : Integrable (g i) (μ : Measure T) := by |
| apply Integrable.of_bound (hf i.val.val i.val.property).measurable.aestronglyMeasurable M |
| exact Filter.Eventually.of_forall fun t => by |
| rw [Real.norm_eq_abs, abs_of_nonneg (hf0 _ i.val.property t)] |
| exact hfM _ i.val.property t |
| let V : Set (I → ℝ) := Set.range (fun μ : ProbabilityMeasure T => |
| fun i => ∫ t, g i t ∂(μ : Measure T)) |
| have hV : Convex ℝ V := convex_integral_vectors g hg |
| have hVne : V.Nonempty := ⟨_, Set.mem_range_self (diracProba (Classical.arbitrary T))⟩ |
| have hmiss : ∀ v ∈ V, ∃ i, v i ≤ b + ε := by |
| rintro v ⟨μ, rfl⟩ |
| obtain ⟨z, hz, hzμ⟩ := mem_iUnion₂.mp (hF (mem_univ μ)) |
| exact ⟨⟨z, hz⟩, le_of_lt hzμ⟩ |
| obtain ⟨w, hw, hw1, hwV⟩ := finite_nonnegative_separator hV hVne (b + ε) hmiss |
| have hpoints (t : T) : ∑ i, w i * f i.val.val t ≤ b + ε := by |
| have h := hwV _ (Set.mem_range_self (diracProba t)) |
| convert h using 1 |
| apply Finset.sum_congr rfl |
| intro i _ |
| congr 1 |
| exact (integral_dirac' (g i) t (hf i.val.val i.val.property).measurable.stronglyMeasurable).symm |
| let e : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm |
| refine ⟨Fintype.card I, fun i => (e i).val.val, fun i => w (e i), |
| fun i => (e i).val.property, fun i => hw (e i), ?_, ?_⟩ |
| · exact (e.sum_comp w).trans hw1 |
| · intro t |
| exact (e.sum_comp (fun i => w i * f i.val.val t)).le.trans (hpoints t) |
|
|
| end CircleDomainRigidity |
|
|
| end |
|
|
| end OAI |
|
|
