| import Mathlib |
| import OAI.Geometry.IntegralFillings.Currents.TestBounds |
|
|
| namespace OAI |
|
|
| section |
| open Filter Set |
| open Set Filter MeasureTheory TopologicalSpace |
| open scoped Topology ENNReal |
| open Set MeasureTheory |
| open scoped RealInnerProductSpace |
| open Matrix |
| open scoped RealInnerProductSpace MatrixOrder |
| open Set MeasureTheory Measure Filter Module |
| open Set Filter MeasureTheory Measure ContinuousLinearMap |
| open scoped Topology Convolution NNReal |
| open Set Filter MeasureTheory Measure Metric |
| open scoped Topology ContDiff |
| open Set Filter Metric |
| open scoped Topology NNReal |
| open Set MeasureTheory Filter |
| open Set Filter MeasureTheory |
| open scoped Topology ENNReal NNReal |
| open MeasureTheory Filter Set Metric |
| open scoped Topology Pointwise NNReal |
|
|
| namespace SharpIntegralFillings |
| open MeasureTheory Set Filter |
| open scoped Topology NNReal |
|
|
| namespace Foundations |
| variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] [CompactSpace X] |
| omit [MeasurableSpace X] [BorelSpace X] in |
| lemma eval_tendsto_of_uniform_modulus {d : ℕ} |
| (F : (Fin d → X → ℝ) → ℝ) (π : Fin d → X → ℝ) |
| (πs : ℕ → Fin d → X → ℝ) |
| (hLip : ∀ i, ∃ K : ℝ≥0, ∀ j, LipschitzWith K (πs j i)) |
| (hpt : ∀ i x, Tendsto (fun j => πs j i x) atTop (𝓝 (π i x))) |
| (hmod : ∀ K : ℝ≥0, ∃ C : ℝ≥0, ∀ (ρ σ : Fin d → X → ℝ), |
| (∀ i, LipschitzWith K (ρ i)) → (∀ i, LipschitzWith K (σ i)) → |
| ∀ ε : ℝ≥0, (∀ i x, |ρ i x - σ i x| ≤ ε) → |F ρ - F σ| ≤ C * ε) : |
| Tendsto (fun j => F (πs j)) atTop (𝓝 (F π)) := by |
| choose Ks hKs using hLip |
| let K : ℝ≥0 := ∑ i, Ks i |
| have hK (i : Fin d) : Ks i ≤ K := |
| Finset.single_le_sum (fun _ _ => bot_le) (Finset.mem_univ i) |
| have hseq (j : ℕ) (i : Fin d) : LipschitzWith K (πs j i) := (hKs i j).weaken (hK i) |
| have hlimit (i : Fin d) : LipschitzWith K (π i) := |
| lipschitz_of_pointwise_limit (fun j => hseq j i) (hpt i) |
| obtain ⟨C, hC⟩ := hmod K |
| apply Metric.tendsto_nhds.mpr |
| intro ε hε |
| let δ : ℝ := ε / ((C : ℝ) + 1) |
| have hδ : 0 < δ := div_pos hε (by positivity) |
| have hev (i : Fin d) : ∀ᶠ j in atTop, ∀ x, |πs j i x - π i x| ≤ δ := by |
| have hu := lipschitz_pointwise_uniform (fun j => hseq j i) (hpt i) |
| filter_upwards [Metric.tendstoUniformly_iff.mp hu δ hδ] with j hj x |
| exact le_of_lt (by simpa [Real.dist_eq, abs_sub_comm] using hj x) |
| filter_upwards [Filter.eventually_all.mpr hev] with j hj |
| rw [Real.dist_eq] |
| have h := hC (πs j) π (hseq j) hlimit ⟨δ, hδ.le⟩ hj |
| refine h.trans_lt ?_ |
| change (C : ℝ) * δ < ε |
| calc (C : ℝ) * δ < ((C : ℝ) + 1) * δ := by nlinarith |
| _ = ε := by dsimp [δ]; exact mul_div_cancel₀ ε (by positivity : (C : ℝ) + 1 ≠ 0) |
|
|
| lemma metricCurrent_of_bounded_weak_limit |
| {ι : Type*} {l : Filter ι} [NeBot l] {k : ℕ} |
| {Ts : ι → Functional X (k + 1)} {T : Functional X (k + 1)} |
| (hTs : ∀ j, IntegerRectifiable (Ts j)) |
| (hcur : ∀ j, IsMetricCurrent (Ts j)) |
| (hbd : ∀ j, IsMetricCurrent (boundarySucc (Ts j))) |
| (M N : ℝ≥0) (hM : ∀ j, mass (Ts j) ≤ M) |
| (hN : ∀ j, mass (boundarySucc (Ts j)) ≤ N) |
| (hlim : ∀ b π, Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : |
| IsMetricCurrent T := by |
| obtain ⟨μ, hμ, hctrl, _⟩ := exists_controls_of_bounded_weak_limit M hcur hM |
| (fun b π _ => hlim b π) |
| refine { |
| offDomain := ?_ |
| linearFirst := ?_ |
| linearCoord := ?_ |
| sequentialContinuity := ?_ |
| locality := ?_ |
| finiteMass := ⟨μ, hμ, hctrl⟩ } |
| · intro b π h |
| apply tendsto_nhds_unique (hlim b π) |
| have heq : (fun j => Ts j b π) = fun _ => 0 := |
| funext fun j => (hcur j).offDomain b π h |
| rw [heq] |
| exact tendsto_const_nhds |
| · intro b₁ b₂ π a c hb₁ hb₂ hπ |
| apply tendsto_nhds_unique (hlim (fun x => a * b₁ x + c * b₂ x) π) |
| convert ((hlim b₁ π).const_mul a).add ((hlim b₂ π).const_mul c) using 1 |
| funext j |
| exact (hcur j).linearFirst b₁ b₂ π a c hb₁ hb₂ hπ |
| · intro b π i f a c hadm hf |
| apply tendsto_nhds_unique (hlim b (Function.update π i (fun x => a * π i x + c * f x))) |
| convert ((hlim b π).const_mul a).add |
| ((hlim b (Function.update π i f)).const_mul c) using 1 |
| funext j |
| exact (hcur j).linearCoord b π i f a c hadm hf |
| · intro b π πs hb hLip hpt |
| obtain ⟨Kb, hKb⟩ := hb.1 |
| obtain ⟨B₀, hB₀⟩ := hb.2 |
| let B : ℝ≥0 := ⟨max B₀ 0, le_max_right _ _⟩ |
| have hB (x : X) : |b x| ≤ B := (hB₀ x).trans (le_max_left _ _) |
| apply eval_tendsto_of_uniform_modulus (T b) π πs hLip hpt |
| intro K |
| let C : ℝ≥0 := (k + 1) * (K + K) ^ k * (B * N + Kb * M) |
| refine ⟨C, ?_⟩ |
| intro ρ σ hρ hσ ε hε |
| have h := weak_limit_test_difference_bound hTs hcur hbd M N hM hN |
| (fun b π _ => hlim b π) hKb ρ σ K hρ hσ B ε hB hε |
| simpa [C] using h |
| · intro b π hadm hloc |
| apply tendsto_nhds_unique (hlim b π) |
| have heq : (fun j => Ts j b π) = fun _ => 0 := |
| funext fun j => (hcur j).locality b π hadm hloc |
| rw [heq] |
| exact tendsto_const_nhds |
|
|
| omit [BorelSpace X] [CompactSpace X] in |
| lemma boundarySucc_boundarySucc {k : ℕ} {T : Functional X (k + 1 + 1)} |
| (hT : IsMetricCurrent T) : boundarySucc (boundarySucc T) = fun _ _ => 0 := by |
| funext b π |
| by_cases h : Admissible b π |
| · rw [boundarySucc, ite_eq_left h] |
| have hadm : Admissible (fun _ : X => (1 : ℝ)) (Matrix.vecCons b π) := |
| admissible_vecCons (BoundedLip.const 1) h.1.1 h.2 |
| rw [boundarySucc, ite_eq_left hadm] |
| apply hT.eq_zero_of_const_coord (admissible_vecCons (BoundedLip.const 1) |
| ⟨0, LipschitzWith.const 1⟩ hadm.2) 0 1 |
| intro x |
| rfl |
| · rw [boundarySucc, ite_eq_right h] |
|
|
| omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in |
| lemma boundarySucc_weak_limit {ι : Type*} {l : Filter ι} {k : ℕ} |
| {Ts : ι → Functional X (k + 1)} {T : Functional X (k + 1)} |
| (hlim : ∀ b π, Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : |
| ∀ b π, Tendsto (fun j => boundarySucc (Ts j) b π) l (𝓝 (boundarySucc T b π)) := by |
| intro b π |
| by_cases h : Admissible b π |
| · simpa only [boundarySucc, ite_eq_left h] using hlim (fun _ => 1) (Matrix.vecCons b π) |
| · simp only [boundarySucc, ite_eq_right h] |
| exact tendsto_const_nhds |
|
|
| lemma normal_of_bounded_integral_weak_limit |
| {ι : Type*} {l : Filter ι} [NeBot l] {k : ℕ} |
| {Ts : ι → Functional X (k + 1 + 1)} {T : Functional X (k + 1 + 1)} |
| (hTs : ∀ j, IsIntegral (k + 1 + 1) (Ts j)) |
| (M N : ℝ≥0) (hM : ∀ j, mass (Ts j) ≤ M) |
| (hN : ∀ j, mass (boundarySucc (Ts j)) ≤ N) |
| (hlim : ∀ b π, Tendsto (fun j => Ts j b π) l (𝓝 (T b π))) : |
| IsMetricCurrent T ∧ IsMetricCurrent (boundarySucc T) := by |
| have hcur (j : ι) := (hTs j).1 |
| have hint (j : ι) := (hTs j).2.1 |
| have hbd (j : ι) := (hTs j).2.2.1 |
| have hbdi (j : ι) := (hTs j).2.2.2 |
| refine ⟨metricCurrent_of_bounded_weak_limit hint hcur hbd M N hM hN hlim, ?_⟩ |
| apply metricCurrent_of_bounded_weak_limit hbdi hbd (fun j => ?_) N 0 hN |
| (fun j => ?_) (boundarySucc_weak_limit hlim) |
| · rw [boundarySucc_boundarySucc (hcur j)] |
| exact isMetricCurrent_zero k |
| · rw [boundarySucc_boundarySucc (hcur j), mass_zero] |
| rfl |
|
|
| end Foundations |
| end SharpIntegralFillings |
| end |
|
|
| end OAI |
|
|
