Download data/lean/OAI/Geometry/IntegralFillings/Currents/TestBounds.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.24 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IntegralFillings/Currents/TestBounds.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/IntegralFillings/Currents/TestBounds.lean
-
curl -L -o TestBounds.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IntegralFillings/Currents/TestBounds.lean
7.24 kB
| import Mathlib | |
| import OAI.Geometry.IntegralFillings.Currents.ProductRule | |
| 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 boundedLip_of_lipschitz {f : X β β} {K : ββ₯0} (hf : LipschitzWith K f) : | |
| BoundedLip f := by | |
| obtain β¨M, hMβ© := isCompact_univ.exists_bound_of_continuousOn hf.continuous.continuousOn | |
| exact β¨β¨K, hfβ©, M, fun x => by simpa [Real.norm_eq_abs] using hM x (mem_univ x)β© | |
| lemma IntegerRectifiable.coord_bound {k : β} {T : Functional X (k + 1)} | |
| (hT : IntegerRectifiable T) (hcur : IsMetricCurrent T) | |
| (hbd : IsMetricCurrent (boundarySucc T)) | |
| {b : X β β} {Kb : ββ₯0} (hb : LipschitzWith Kb b) | |
| (Ο : Fin (k + 1) β X β β) (K : ββ₯0) | |
| (hΟ : β i, LipschitzWith K (Ο i)) (i : Fin (k + 1)) | |
| (B F : ββ₯0) (hB : β x, |b x| β€ B) (hF : β x, |Ο i x| β€ F) : | |
| |T b Ο| β€ (K : β) ^ k * | |
| ((B : β) * mass (boundarySucc T) + (Kb : β) * mass T) * F := by | |
| let Ο : Equiv.Perm (Fin (k + 1)) := Equiv.swap 0 i | |
| let Ο : Fin k β X β β := fun j => Ο (Ο j.succ) | |
| have hadm : Admissible b Ο := β¨β¨β¨Kb, hbβ©, B, hBβ©, fun j => β¨K, hΟ jβ©β© | |
| have heq : Ο β Ο = Matrix.vecCons (Ο i) Ο := by | |
| funext j | |
| refine Fin.cases ?_ (fun j => ?_) j | |
| Β· simp [Ο] | |
| Β· rfl | |
| rw [β IntegerRectifiable.abs_apply_permute hT hadm Ο, heq] | |
| have h := IntegerRectifiable.head_bound hT hcur hbd hb | |
| (boundedLip_of_lipschitz (hΟ i)) Ο (fun _ => K) (fun j => hΟ (Ο j.succ)) B F hB hF | |
| simpa using h | |
| lemma IntegerRectifiable.test_difference_bound {k : β} {T : Functional X (k + 1)} | |
| (hT : IntegerRectifiable T) (hcur : IsMetricCurrent T) | |
| (hbd : IsMetricCurrent (boundarySucc T)) | |
| {b : X β β} {Kb : ββ₯0} (hb : LipschitzWith Kb b) | |
| (Ο Ο : Fin (k + 1) β X β β) (K : ββ₯0) | |
| (hΟ : β i, LipschitzWith K (Ο i)) (hΟ : β i, LipschitzWith K (Ο i)) | |
| (B Ξ΅ : ββ₯0) (hB : β x, |b x| β€ B) (hΞ΅ : β i x, |Ο i x - Ο i x| β€ Ξ΅) : | |
| |T b Ο - T b Ο| β€ (k + 1 : β) * ((K + K : ββ₯0) : β) ^ k * | |
| ((B : β) * mass (boundarySucc T) + (Kb : β) * mass T) * Ξ΅ := by | |
| let a : Fin (k + 1) β lipSubmodule (X := X) := fun i => β¨Ο i, K, hΟ iβ© | |
| let c : Fin (k + 1) β lipSubmodule (X := X) := fun i => β¨Ο i, K, hΟ iβ© | |
| let Ο : Fin (k + 1) β Fin (k + 1) β X β β := fun i j => | |
| if j < i then Ο j else if i = j then fun x => Ο j x - Ο j x else Ο j | |
| have heq : T b Ο - T b Ο = β i, T b (Ο i) := by | |
| have h := (hcur.multilinear b β¨β¨Kb, hbβ©, B, hBβ©).map_sub_map_piecewise a c Finset.univ | |
| simp only [Finset.mem_univ, forall_const, Finset.piecewise_univ] at h | |
| change T b Ο - T b Ο = _ at h | |
| rw [h] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| change T b _ = T b _ | |
| congr 1 | |
| funext j | |
| dsimp [Ο] | |
| split_ifs <;> rfl | |
| have hΟ (i j : Fin (k + 1)) : LipschitzWith (K + K) (Ο i j) := by | |
| dsimp [Ο] | |
| split_ifs | |
| Β· exact (hΟ j).weaken (le_add_of_nonneg_right (show (0 : ββ₯0) β€ K from bot_le)) | |
| Β· exact (hΟ j).sub (hΟ j) | |
| Β· exact (hΟ j).weaken (le_add_of_nonneg_right (show (0 : ββ₯0) β€ K from bot_le)) | |
| have hΟi (i : Fin (k + 1)) (x : X) : |Ο i i x| β€ Ξ΅ := by | |
| simpa [Ο] using hΞ΅ i x | |
| rw [heq] | |
| calc |β i, T b (Ο i)| β€ β i, |T b (Ο i)| := Finset.abs_sum_le_sum_abs _ _ | |
| _ β€ β _i : Fin (k + 1), ((K + K : ββ₯0) : β) ^ k * | |
| ((B : β) * mass (boundarySucc T) + (Kb : β) * mass T) * Ξ΅ := | |
| Finset.sum_le_sum fun i _ => IntegerRectifiable.coord_bound hT hcur hbd hb | |
| (Ο i) (K + K) (hΟ i) i B Ξ΅ hB (hΟi i) | |
| _ = _ := by simp; ring | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma lipschitz_pointwise_uniform {ΞΉ : Type*} {l : Filter ΞΉ} | |
| {f : ΞΉ β X β β} {g : X β β} {K : ββ₯0} | |
| (hf : β i, LipschitzWith K (f i)) (hg : β x, Tendsto (fun i => f i x) l (π (g x))) : | |
| TendstoUniformly f g l := by | |
| have heq : Equicontinuous f := Metric.equicontinuous_of_continuity_modulus | |
| (fun r : β => (K : β) * r) (by simpa using (tendsto_const_nhds (x := (K : β))).mul (show Tendsto (fun r : β => r) (π 0) (π 0) from tendsto_id)) f | |
| (fun x y i => (hf i).dist_le_mul x y) | |
| have ht := (heq.tendsto_uniformFun_iff_pi l g).mpr (tendsto_pi_nhds.mpr hg) | |
| exact UniformFun.tendsto_iff_tendstoUniformly.mp ht | |
| lemma weak_limit_test_difference_bound | |
| {ΞΉ : 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 Ο, Admissible b Ο β Tendsto (fun j => Ts j b Ο) l (π (T b Ο))) | |
| {b : X β β} {Kb : ββ₯0} (hb : LipschitzWith Kb b) | |
| (Ο Ο : Fin (k + 1) β X β β) (K : ββ₯0) | |
| (hΟ : β i, LipschitzWith K (Ο i)) (hΟ : β i, LipschitzWith K (Ο i)) | |
| (B Ξ΅ : ββ₯0) (hB : β x, |b x| β€ B) (hΞ΅ : β i x, |Ο i x - Ο i x| β€ Ξ΅) : | |
| |T b Ο - T b Ο| β€ (k + 1 : β) * ((K + K : ββ₯0) : β) ^ k * | |
| ((B : β) * N + (Kb : β) * M) * Ξ΅ := by | |
| have hb' : BoundedLip b := β¨β¨Kb, hbβ©, B, hBβ© | |
| apply le_of_tendsto ((hlim b Ο β¨hb', fun i => β¨K, hΟ iβ©β©).sub | |
| (hlim b Ο β¨hb', fun i => β¨K, hΟ iβ©β©)).abs | |
| apply Eventually.of_forall | |
| intro j | |
| refine (IntegerRectifiable.test_difference_bound (hTs j) (hcur j) (hbd j) hb | |
| Ο Ο K hΟ hΟ B Ξ΅ hB hΞ΅).trans ?_ | |
| apply mul_le_mul_of_nonneg_right _ Ξ΅.coe_nonneg | |
| apply mul_le_mul_of_nonneg_left _ (by positivity) | |
| exact add_le_add (mul_le_mul_of_nonneg_left (hN j) B.coe_nonneg) | |
| (mul_le_mul_of_nonneg_left (hM j) Kb.coe_nonneg) | |
| omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in | |
| lemma lipschitz_of_pointwise_limit {ΞΉ : Type*} {l : Filter ΞΉ} [NeBot l] | |
| {f : ΞΉ β X β β} {g : X β β} {K : ββ₯0} | |
| (hf : β i, LipschitzWith K (f i)) (hg : β x, Tendsto (fun i => f i x) l (π (g x))) : | |
| LipschitzWith K g := by | |
| apply lipschitzWith_iff_dist_le_mul.mpr | |
| intro x y | |
| exact le_of_tendsto ((hg x).dist (hg y)) | |
| (Eventually.of_forall fun i => (hf i).dist_le_mul x y) | |
| end Foundations | |
| end SharpIntegralFillings | |
| end | |
| end OAI | |