| import Mathlib |
| import OAI.Geometry.IntegralFillings.Currents.MassBounds |
|
|
| namespace OAI |
|
|
| section |
| open Set Filter MeasureTheory |
| open scoped Topology ENNReal NNReal |
|
|
| namespace SharpIntegralFillings |
| attribute [local instance] Classical.propDecidable |
| universe u |
| section Foundations |
| variable {X : Type u} [MetricSpace X] [MeasurableSpace X] |
| open scoped BoundedContinuousFunction |
|
|
| variable [BorelSpace X] |
| lemma controls_of_weak_limits {ι : Type*} {l : Filter ι} [NeBot l] |
| {k : ℕ} {Ts : ι → Functional X k} {T : Functional X k} |
| {μs : ι → FiniteMeasure X} {μ : FiniteMeasure X} |
| (hμ : Tendsto μs l (𝓝 μ)) (hc : ∀ j, Controls (Ts j) (μs j : Measure X)) |
| (hT : ∀ b π, Admissible b π → |
| Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : Controls T (μ : Measure X) := by |
| intro b π hb hπ |
| exact le_of_tendsto_of_tendsto |
| (Filter.Tendsto.abs (hT b π ⟨hb, fun i => ⟨1, hπ i⟩⟩)) |
| ((continuous_integral_abs_boundedLip hb).tendsto μ |>.comp hμ) |
| (Eventually.of_forall fun j => hc j b π hb hπ) |
|
|
| lemma exists_controls_of_bounded_weak_limit [CompactSpace X] |
| {ι : Type*} {l : Filter ι} [NeBot l] {k : ℕ} |
| {Ts : ι → Functional X k} {T : Functional X k} (M : ℝ≥0) |
| (hTs : ∀ j, IsMetricCurrent (Ts j)) (hbound : ∀ j, mass (Ts j) ≤ (M : ℝ)) |
| (hlim : ∀ b π, Admissible b π → Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : |
| ∃ μ : Measure X, IsFiniteMeasure μ ∧ Controls T μ ∧ μ.real univ ≤ (M : ℝ) := by |
| choose μj hfin hcontrol heq using fun j => (hTs j).exists_controls_mass_eq |
| let νs : ι → FiniteMeasure X := fun j => ⟨μj j, hfin j⟩ |
| have hbound' : ∀ j, νs j ∈ {ν : FiniteMeasure X | ν.mass ≤ M} := by |
| intro j |
| change (νs j).mass ≤ M |
| apply NNReal.coe_le_coe.mp |
| change (μj j).real univ ≤ (M : ℝ) |
| rw [← heq] |
| exact hbound j |
| obtain ⟨ν, hν, hcluster⟩ := |
| (isCompact_setOfPred_finiteMeasure_le_of_compactSpace X M).exists_mapClusterPt_of_frequently (l := l) |
| (Eventually.of_forall hbound').frequently |
| let l' := comap νs (𝓝 ν) ⊓ l |
| have hl' : NeBot l' := neBot_inf_comap_iff_map'.mpr hcluster |
| let := hl' |
| have hνs : Tendsto νs l' (𝓝 ν) := tendsto_iff_comap.mpr inf_le_left |
| have hctrl : Controls T (ν : Measure X) := |
| controls_of_weak_limits hνs hcontrol (fun b π h => (hlim b π h).mono_left inf_le_right) |
| exact ⟨ν, inferInstance, hctrl, NNReal.coe_le_coe.mpr hν⟩ |
|
|
| lemma mass_le_of_bounded_weak_limit [CompactSpace X] |
| {ι : Type*} {l : Filter ι} [NeBot l] {k : ℕ} |
| {Ts : ι → Functional X k} {T : Functional X k} (M : ℝ≥0) |
| (hTs : ∀ j, IsMetricCurrent (Ts j)) (hbound : ∀ j, mass (Ts j) ≤ (M : ℝ)) |
| (hlim : ∀ b π, Admissible b π → Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : |
| mass T ≤ (M : ℝ) := by |
| obtain ⟨μ, hfin, hcontrol, hmass⟩ := |
| exists_controls_of_bounded_weak_limit M hTs hbound hlim |
| exact (mass_le_measure hfin hcontrol).trans hmass |
|
|
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma BoundedLip.mul {b c : X → ℝ} (hb : BoundedLip b) (hc : BoundedLip c) : |
| BoundedLip (fun x => b x * c x) := by |
| obtain ⟨⟨Kb, hKb⟩, Mb, hMb⟩ := hb |
| obtain ⟨⟨Kc, hKc⟩, Mc, hMc⟩ := hc |
| let B : ℝ≥0 := ⟨max Mb 0, le_max_right _ _⟩ |
| let C : ℝ≥0 := ⟨max Mc 0, le_max_right _ _⟩ |
| have hB (x : X) : |b x| ≤ (B : ℝ) := (hMb x).trans (le_max_left _ _) |
| have hC (x : X) : |c x| ≤ (C : ℝ) := (hMc x).trans (le_max_left _ _) |
| refine ⟨⟨B * Kc + C * Kb, ?_⟩, (B : ℝ) * (C : ℝ), ?_⟩ |
| · apply lipschitzWith_iff_dist_le_mul.mpr |
| intro x y |
| rw [Real.dist_eq] |
| calc |b x * c x - b y * c y| = |b x * (c x - c y) + (b x - b y) * c y| := by |
| congr 1; ring |
| _ ≤ |b x| * |c x - c y| + |b x - b y| * |c y| := by |
| simpa only [abs_mul] using abs_add_le (b x * (c x - c y)) ((b x - b y) * c y) |
| _ ≤ (B : ℝ) * ((Kc : ℝ) * dist x y) + ((Kb : ℝ) * dist x y) * (C : ℝ) := by |
| apply add_le_add |
| · exact mul_le_mul (hB x) (hKc.dist_le_mul x y) (abs_nonneg _) B.coe_nonneg |
| · exact mul_le_mul (hKb.dist_le_mul x y) (hC y) (abs_nonneg _) |
| (mul_nonneg Kb.coe_nonneg dist_nonneg) |
| _ = ((B * Kc + C * Kb : ℝ≥0) : ℝ) * dist x y := by push_cast; ring |
| · intro x |
| rw [abs_mul] |
| exact mul_le_mul (hB x) (hC x) (abs_nonneg _) B.coe_nonneg |
|
|
| lemma IsMetricCurrent.mass_bound_uniform [CompactSpace X] |
| {k : ℕ} {T : Functional X k} (hT : IsMetricCurrent T) |
| {b : X → ℝ} (hb : BoundedLip b) {π : Fin k → X → ℝ} |
| (K : Fin k → ℝ≥0) (hK : ∀ i, LipschitzWith (K i) (π i)) |
| {M : ℝ} (hM : ∀ x, |b x| ≤ M) : |
| |T b π| ≤ ((∏ i, (K i : ℝ)) * M) * mass T := by |
| obtain ⟨μ, hfin, hcontrol, heq⟩ := hT.exists_controls_mass_eq |
| let := hfin |
| have hint : Integrable (fun x => |b x|) μ := (hb.toBoundedContinuous.integrable μ).abs |
| have hbound : (∫ x, |b x| ∂μ) ≤ μ.real univ * M := by |
| simpa using integral_mono hint (integrable_const M) hM |
| calc |T b π| ≤ (∏ i, (K i : ℝ)) * ∫ x, |b x| ∂μ := hT.mass_bound hcontrol hb K hK |
| _ ≤ (∏ i, (K i : ℝ)) * (μ.real univ * M) := |
| mul_le_mul_of_nonneg_left hbound (Finset.prod_nonneg fun i _ => (K i).coe_nonneg) |
| _ = ((∏ i, (K i : ℝ)) * M) * mass T := by rw [heq]; ring |
|
|
| lemma IsMetricCurrent.eq_zero_of_mass_eq_zero [CompactSpace X] |
| {k : ℕ} {T : Functional X k} (hT : IsMetricCurrent T) (hm : mass T = 0) : |
| T = fun _ _ => 0 := by |
| funext b π |
| by_cases h : Admissible b π |
| · choose K hK using h.2 |
| obtain ⟨M, hM⟩ := h.1.2 |
| have hle := hT.mass_bound_uniform h.1 K hK hM |
| rw [hm, mul_zero] at hle |
| exact abs_eq_zero.mp (le_antisymm hle (abs_nonneg _)) |
| · exact hT.offDomain b π h |
|
|
| end Foundations |
| end SharpIntegralFillings |
| end |
|
|
| end OAI |
|
|
