Download data/lean/OAI/Dynamics/TriangleBilliards/WeakCompactness.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/TriangleBilliards/WeakCompactness.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/TriangleBilliards/WeakCompactness.lean
-
curl -L -o WeakCompactness.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/TriangleBilliards/WeakCompactness.lean
12.2 kB
| import OAI.Dynamics.TriangleBilliards.RegularizedModes | |
| namespace OAI | |
| universe uAlpha uBeta uE uF uIota uKappa | |
| open MeasureTheory Set | |
| open scoped ENNReal symmDiff | |
| noncomputable section | |
| open MeasureTheory Set Filter Function Metric | |
| open scoped Topology Convolution ContDiff | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| noncomputable section | |
| open MeasureTheory Set Filter BoundedContinuousFunction | |
| open scoped ENNReal Topology ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open Filter Finset Set | |
| open scoped Topology BigOperators | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ContDiff NNReal | |
| open MeasureTheory Filter Set | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open Filter Set | |
| open scoped Topology | |
| noncomputable section | |
| namespace TriangularBilliards.Analytic | |
| section Weak | |
| variable {E : Type uE} {F : Type uF} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {Ξ± : Type uAlpha} {l : Filter Ξ±} | |
| /-- Scalar-test characterization of weak convergence over the real field. -/ | |
| def WeaklyTendsto (u : Ξ± β E) (l : Filter Ξ±) (v : E) : Prop := | |
| β L : E βL[β] β, Tendsto (fun n => L (u n)) l (π (L v)) | |
| lemma weaklyTendsto_of_tendsto {u : Ξ± β E} {v : E} | |
| (h : Tendsto u l (π v)) : WeaklyTendsto u l v := | |
| fun L => L.continuous.continuousAt.tendsto.comp h | |
| lemma WeaklyTendsto.comp {u : Ξ± β E} {v : E} (h : WeaklyTendsto u l v) | |
| {Ξ² : Type uBeta} {m : Filter Ξ²} {Ο : Ξ² β Ξ±} (hΟ : Tendsto Ο m l) : | |
| WeaklyTendsto (u β Ο) m v := | |
| fun L => (h L).comp hΟ | |
| lemma WeaklyTendsto.prod {u : Ξ± β E} {v : Ξ± β F} {a : E} {b : F} | |
| (hu : WeaklyTendsto u l a) (hv : WeaklyTendsto v l b) : | |
| WeaklyTendsto (fun n => (u n, v n)) l (a, b) := by | |
| intro L | |
| have h := (hu (L.comp (ContinuousLinearMap.inl β E F))).add | |
| (hv (L.comp (ContinuousLinearMap.inr β E F))) | |
| simpa only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.inl_apply, | |
| ContinuousLinearMap.inr_apply, β map_add, Prod.add_def, add_zero, zero_add] using h | |
| lemma WeaklyTendsto.sub_const {u : Ξ± β E} {v : E} | |
| (h : WeaklyTendsto u l v) (w : E) : | |
| WeaklyTendsto (fun n => u n - w) l (v - w) := by | |
| intro L | |
| simpa only [map_sub] using (h L).sub_const (L w) | |
| /-- Norm-closed convex sets remain closed under weak limits. In particular | |
| this applies to a uniform Lβ bound inside LΒ² and to a closed derivative graph. -/ | |
| lemma WeaklyTendsto.mem_of_closed_convex [l.NeBot] {u : Ξ± β E} {v : E} | |
| (h : WeaklyTendsto u l v) {C : Set E} (hc : IsClosed C) (hcv : Convex β C) | |
| (hu : βαΆ n in l, u n β C) : v β C := by | |
| by_contra hn | |
| obtain β¨L, t, hC, hvβ© := geometric_hahn_banach_closed_point hcv hc hn | |
| have hle : L v β€ t := le_of_tendsto (h L) (hu.mono fun n hn => (hC _ hn).le) | |
| exact (not_le_of_gt hv) hle | |
| lemma WeaklyTendsto.norm_le [l.NeBot] {u : Ξ± β E} {v : E} | |
| (h : WeaklyTendsto u l v) {r : β} (hu : βαΆ n in l, βu nβ β€ r) : βvβ β€ r := by | |
| have hv := h.mem_of_closed_convex Metric.isClosed_closedBall (convex_closedBall (0 : E) r) | |
| (hu.mono fun n hn => (mem_closedBall_zero_iff).mpr hn) | |
| exact mem_closedBall_zero_iff.mp hv | |
| lemma WeaklyTendsto.norm_le_of_bounds [l.NeBot] {u : Ξ± β E} {v : E} | |
| (h : WeaklyTendsto u l v) {r : Ξ± β β} {R : β} | |
| (hr : Tendsto r l (π R)) (hu : βαΆ n in l, βu nβ β€ r n) : βvβ β€ R := by | |
| apply le_of_forall_pos_le_add | |
| intro Ξ΅ hΞ΅ | |
| apply h.norm_le | |
| filter_upwards [hu, hr.eventually (gt_mem_nhds (show R < R + Ξ΅ by linarith))] | |
| with n hn hrn | |
| exact hn.trans hrn.le | |
| end Weak | |
| section Hilbert | |
| variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace β E] | |
| [CompleteSpace E] [TopologicalSpace.SeparableSpace E] | |
| /-- Weak sequential compactness of a bounded set in a separable real Hilbert | |
| space, obtained from BanachβAlaoglu and Riesz. -/ | |
| lemma exists_weak_subsequence (u : β β E) {R : β} (hu : β n, βu nβ β€ R) : | |
| β v : E, βvβ β€ R β§ β Ο : β β β, StrictMono Ο β§ WeaklyTendsto (u β Ο) atTop v := by | |
| let J := InnerProductSpace.toDual β E | |
| let w : β β WeakDual β E := fun n => StrongDual.toWeakDual (J (u n)) | |
| have hw : β n, w n β WeakDual.toStrongDual β»ΒΉ' Metric.closedBall (0 : StrongDual β E) R := by | |
| intro n | |
| change dist (J (u n)) 0 β€ R | |
| simpa only [dist_zero_right, LinearIsometryEquiv.norm_map] using hu n | |
| obtain β¨a, ha, Ο, hΟ, hlimβ© := (WeakDual.isSeqCompact_closedBall β E 0 R) hw | |
| let v : E := J.symm (WeakDual.toStrongDual a) | |
| have hv : βvβ β€ R := by | |
| simpa only [Set.mem_preimage, Metric.mem_closedBall, dist_zero_right, v, | |
| LinearIsometryEquiv.norm_map] using ha | |
| refine β¨v, hv, Ο, hΟ, ?_β© | |
| intro L | |
| let x : E := J.symm L | |
| have heq (y : E) : (J y) x = L y := by | |
| change inner β y (J.symm L) = L y | |
| rw [real_inner_comm] | |
| exact InnerProductSpace.toDual_symm_apply | |
| have heqa : a x = L v := by | |
| change (WeakDual.toStrongDual a) x = L v | |
| have hj : J v = WeakDual.toStrongDual a := J.apply_symm_apply _ | |
| rw [β hj, heq] | |
| have h := (WeakDual.eval_continuous x).continuousAt.tendsto.comp hlim | |
| change Tendsto (fun n => (J (u (Ο n))) x) atTop (π (a x)) at h | |
| simpa only [heq, heqa, Function.comp_apply] using h | |
| end Hilbert | |
| section DerivativeGraph | |
| variable {E : Type uE} {F : Type uF} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| /-- A distributional graph described by test identities. Instantiating it | |
| with weak differentiation requires constructing its actual test functionals. -/ | |
| def TestGraph {ΞΉ : Type uIota} (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) : Set (E Γ F) := | |
| {p | β i, A i p.1 = B i p.2} | |
| lemma testGraph_closed {ΞΉ : Type uIota} (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) : | |
| IsClosed (TestGraph A B) := by | |
| have h : TestGraph A B = β i, {p : E Γ F | A i p.1 = B i p.2} := by | |
| ext p | |
| simp only [TestGraph, mem_ofPred_eq, mem_iInter] | |
| rw [h] | |
| exact isClosed_iInter fun i => isClosed_eq ((A i).continuous.comp continuous_fst) | |
| ((B i).continuous.comp continuous_snd) | |
| lemma testGraph_convex {ΞΉ : Type uIota} (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) : | |
| Convex β (TestGraph A B) := by | |
| intro p hp q hq a b _ _ _ i | |
| simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, | |
| map_add, map_smul, hp i, hq i] | |
| /-- Identifying the weak derivative limit uses only test identities, not | |
| an unjustified claim that the entire horizontal derivative lies in LΒ². -/ | |
| lemma testGraph_weak_limit {ΞΉ : Type uIota} {Ξ± : Type uAlpha} (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) | |
| {l : Filter Ξ±} [l.NeBot] {u : Ξ± β E} {d : Ξ± β F} {v : E} {e : F} | |
| (hu : WeaklyTendsto u l v) (hd : WeaklyTendsto d l e) | |
| (hgraph : βαΆ n in l, (u n, d n) β TestGraph A B) : (v, e) β TestGraph A B := | |
| (hu.prod hd).mem_of_closed_convex (testGraph_closed A B) (testGraph_convex A B) hgraph | |
| end DerivativeGraph | |
| section TestGraphLimits | |
| variable {E : Type uE} {F : Type uF} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [InnerProductSpace β F] | |
| [CompleteSpace F] [TopologicalSpace.SeparableSpace F] | |
| omit [CompleteSpace F] [TopologicalSpace.SeparableSpace F] in | |
| lemma testGraph_unique {ΞΉ : Type uIota} (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) | |
| (hsep : β v : F, (β i, B i v = 0) β v = 0) | |
| {u : E} {d e : F} (hd : (u, d) β TestGraph A B) (he : (u, e) β TestGraph A B) : | |
| d = e := by | |
| apply sub_eq_zero.mp | |
| apply hsep | |
| intro i | |
| rw [map_sub, β hd i, β he i, sub_self] | |
| /-- The second-limit step: strong convergence of the functions and a | |
| uniform bound for only the relevant derivatives suffice to pass a fixed | |
| pairing to the limit. There is no bound for the sum of all mode derivatives. -/ | |
| lemma testGraph_pairing_of_strong_limit {ΞΉ : Type uIota} | |
| (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) | |
| (hsep : β v : F, (β i, B i v = 0) β v = 0) | |
| (u : β β E) (d : β β F) {f : E} {e : F} {R : β} | |
| (hgraph : β n, (u n, d n) β TestGraph A B) | |
| (hf : (f, e) β TestGraph A B) | |
| (hu : Tendsto u atTop (π f)) (hd : β n, βd nβ β€ R) | |
| (L : F βL[β] β) (hL : Tendsto (fun n => L (d n)) atTop (π 0)) : L e = 0 := by | |
| obtain β¨e', _, Ο, hΟ, he'β© := exists_weak_subsequence d hd | |
| have hfu := (weaklyTendsto_of_tendsto hu).comp hΟ.tendsto_atTop | |
| have hfe' : (f, e') β TestGraph A B := | |
| testGraph_weak_limit A B hfu he' (Eventually.of_forall fun n => hgraph (Ο n)) | |
| have heq := testGraph_unique A B hsep hfe' hf | |
| have hzero : L e' = 0 := tendsto_nhds_unique (he' L) (hL.comp hΟ.tendsto_atTop) | |
| simpa only [heq] using hzero | |
| end TestGraphLimits | |
| section FirstLimit | |
| variable {E : Type uE} {F : Type uF} [NormedAddCommGroup E] [InnerProductSpace β E] | |
| [NormedAddCommGroup F] [InnerProductSpace β F] | |
| [CompleteSpace E] [TopologicalSpace.SeparableSpace E] | |
| [CompleteSpace F] [TopologicalSpace.SeparableSpace F] | |
| /-- The fixed-clearance-budget weak limit. The derivative bound `M` is | |
| allowed to depend on that fixed budget. An application must supply all | |
| smoothing, support, transport and distributional-graph properties; this | |
| lemma supplies the two subsequence extractions and all limit passages. -/ | |
| lemma testGraph_first_limit {ΞΉ : Type uIota} {ΞΊ : Type uKappa} | |
| (A : ΞΉ β E βL[β] β) (B : ΞΉ β F βL[β] β) (X : ΞΊ β E βL[β] β) | |
| (C : Set E) (hCclosed : IsClosed C) (hCconvex : Convex β C) | |
| (u : β β E) (d : β β F) {f : E} {H M Ξ΄ : β} (Ξ΄n : β β β) | |
| (hu : β n, βu nβ β€ H) (hd : β n, βd nβ β€ M) | |
| (hC : β n, u n β C) (hgraph : β n, (u n, d n) β TestGraph A B) | |
| (hX : β k, Tendsto (fun n => X k (u n)) atTop (π 0)) | |
| (hΞ΄n : Tendsto Ξ΄n atTop (π Ξ΄)) (hclose : β n, βu n - fβ β€ Ξ΄n n) | |
| (L : F βL[β] β) (hL : Tendsto (fun n => L (d n)) atTop (π 0)) : | |
| β g : E, β e : F, | |
| g β C β§ (β k, X k g = 0) β§ βg - fβ β€ Ξ΄ β§ (g, e) β TestGraph A B β§ L e = 0 := by | |
| obtain β¨g, _, Ο, hΟ, hgβ© := exists_weak_subsequence u hu | |
| obtain β¨e, _, Ο, hΟ, heβ© := exists_weak_subsequence (d β Ο) (fun n => hd (Ο n)) | |
| have hw : WeaklyTendsto (u β Ο β Ο) atTop g := hg.comp hΟ.tendsto_atTop | |
| have hΟΟ : Tendsto (Ο β Ο) atTop atTop := hΟ.tendsto_atTop.comp hΟ.tendsto_atTop | |
| refine β¨g, e, ?_, ?_, ?_, ?_, ?_β© | |
| Β· exact hw.mem_of_closed_convex hCclosed hCconvex | |
| (Eventually.of_forall fun n => hC (Ο (Ο n))) | |
| Β· intro k | |
| exact tendsto_nhds_unique (hw (X k)) ((hX k).comp hΟΟ) | |
| Β· exact (hw.sub_const f).norm_le_of_bounds (hΞ΄n.comp hΟΟ) | |
| (Eventually.of_forall fun n => hclose (Ο (Ο n))) | |
| Β· exact testGraph_weak_limit A B hw he | |
| (Eventually.of_forall fun n => hgraph (Ο (Ο n))) | |
| Β· exact tendsto_nhds_unique (he L) (hL.comp hΟΟ) | |
| end FirstLimit | |
| end TriangularBilliards.Analytic | |
| namespace TriangularBilliards.Analytic | |
| lemma exists_weak_subsequence_unrestricted | |
| {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace β E] [CompleteSpace E] | |
| (u : β β E) {R : β} (hu : β n, βu nβ β€ R) : | |
| β v : E, βvβ β€ R β§ β Ο : β β β, StrictMono Ο β§ WeaklyTendsto (u β Ο) atTop v := by | |
| let S := (Submodule.span β (Set.range u)).topologicalClosure | |
| have hS : TopologicalSpace.IsSeparable (S : Set E) := | |
| ((Set.countable_range u).isSeparable.span (R := β)).closure | |
| let : TopologicalSpace.SeparableSpace S := hS.separableSpace | |
| let w (n : β) : S := β¨u n, Submodule.le_topologicalClosure _ | |
| (Submodule.subset_span (Set.mem_range_self n))β© | |
| obtain β¨v,hv,Ο,hΟ,hwβ© := exists_weak_subsequence w hu | |
| refine β¨v.val,hv,Ο,hΟ,?_β© | |
| intro L | |
| exact hw (L.comp S.subtypeL) | |
| end TriangularBilliards.Analytic | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end OAI | |