| import OAI.Dynamics.ThreeTorus.Stages |
|
|
| namespace OAI |
|
|
| /-! All-order local smooth jet limits, positive and negative iterate diagonal, cover descent, and volume preservation. -/ |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter |
| open scoped Topology ContDiff |
| namespace ThreeTorus |
|
|
| /-- Locally uniform limits of EVERY actual spatial jet are a smooth map. |
| The limiting derivative data are not an assumed smooth diagonal. -/ |
| theorem smooth_of_jet_limits {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| (f : ℕ → E → F) (hf : ∀ n, ContDiff ℝ ∞ (f n)) |
| (q : (d : ℕ) → E → E [×d]→L[ℝ] F) |
| (hq : ∀ d, TendstoLocallyUniformly (fun n => iteratedFDeriv ℝ d (f n)) (q d) atTop) : |
| ContDiff ℝ ∞ (fun x => (q 0 x).curry0) := by |
| refine ⟨fun x d => q d x, ?_⟩ |
| refine ⟨fun _ => rfl,?_,?_⟩ |
| · intro d hd x |
| let e := continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (d+1) => E) F |
| have hconv := e.isometry.uniformContinuous.comp_tendstoLocallyUniformly (hq (d+1)) |
| apply hasFDerivAt_of_tendstoLocallyUniformlyOn isOpen_univ |
| hconv.tendstoLocallyUniformlyOn |
| · intro n y _ |
| exact (hf n).ftaylorSeries.fderiv d hd y |
| · intro y _ |
| exact (hq d).tendstoLocallyUniformlyOn.tendsto_at (mem_univ y) |
| · trivial |
| · intro d hd |
| exact (hq d).continuous (.of_forall fun n => (hf n).continuous_iteratedFDeriv hd) |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter |
| open scoped Topology BigOperators ContDiff |
| namespace ThreeTorus |
|
|
| /-- A canonical local limit; no pointwise convergence or smooth limit is assumed. -/ |
| def incrementLimit {X F : Type*} [NormedAddCommGroup F] (f : ℕ → X → F) (x : X) : F := |
| f 0 x + ∑' n, (f (n+1) x-f n x) |
|
|
| lemma uniform_incrementLimit {X F : Type*} [NormedAddCommGroup F] [CompleteSpace F] |
| (f : ℕ → X → F) {s : Set X} {b : ℕ → ℝ} (hb : Summable b) |
| (h : ∀ᶠ n in atTop, ∀ x ∈ s, dist (f (n+1) x) (f n x) ≤ b n) : |
| TendstoUniformlyOn f (incrementLimit f) atTop s := by |
| have ht := tendstoUniformlyOn_tsum_nat_eventually hb (h.mono fun n hn x hx => |
| show ‖f (n+1) x-f n x‖ ≤ b n by simpa only [dist_eq_norm] using hn x hx) |
| apply Metric.tendstoUniformlyOn_iff.mpr |
| intro ε hε |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp ht ε hε] with n hn |
| intro x hx |
| specialize hn x hx |
| rw [Finset.sum_range_sub (fun k => f k x)] at hn |
| convert hn using 1 |
| rw [dist_eq_norm,dist_eq_norm,incrementLimit] |
| congr 1 |
| abel |
|
|
| /-- Summable changes on increasing balls and increasing derivative orders |
| produce a genuine smooth diagonal with locally uniform convergence of ALL |
| jets. This is the completeness step used after the finite-stage producer. -/ |
| theorem smooth_diagonal_of_summable_jets {E F : Type*} |
| [NormedAddCommGroup E] [NormedSpace ℝ E] [LocallyCompactSpace E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F] |
| (f : ℕ → E → F) (hf : ∀ n, ContDiff ℝ ∞ (f n)) |
| {b : ℕ → ℝ} (hb : Summable b) |
| (hstep : ∀ (n d : ℕ), d ≤ n → ∀ x : E, ‖x‖ ≤ (n:ℝ) → |
| dist (iteratedFDeriv ℝ d (f (n+1)) x) (iteratedFDeriv ℝ d (f n) x) ≤ b n) : |
| ∃ g : E → F, ContDiff ℝ ∞ g ∧ TendstoLocallyUniformly f g atTop ∧ |
| ∀ d : ℕ, TendstoLocallyUniformly (fun n => iteratedFDeriv ℝ d (f n)) |
| (incrementLimit (fun n => iteratedFDeriv ℝ d (f n))) atTop := by |
| let q (d : ℕ) := incrementLimit (fun n => iteratedFDeriv ℝ d (f n)) |
| have hq (d : ℕ) : TendstoLocallyUniformly (fun n => iteratedFDeriv ℝ d (f n)) (q d) atTop := by |
| apply tendstoLocallyUniformly_iff_forall_isCompact.mpr |
| intro K hK |
| obtain ⟨r,hr⟩ := hK.isBounded.subset_closedBall (0:E) |
| apply uniform_incrementLimit _ hb |
| have hn : ∀ᶠ n : ℕ in atTop, r ≤ (n:ℝ) := |
| tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _) |
| filter_upwards [hn,eventually_ge_atTop d] with n hn hnd |
| intro x hx |
| apply hstep n d hnd x |
| have hxnorm : ‖x‖ ≤ r := by simpa only [Metric.mem_closedBall,dist_zero_right] using hr hx |
| exact hxnorm.trans hn |
| refine ⟨fun x => (q 0 x).curry0,smooth_of_jet_limits f hf q hq,?_,hq⟩ |
| have hh := (continuousMultilinearCurryFin0 ℝ E F).isometry.uniformContinuous.comp_tendstoLocallyUniformly (hq 0) |
| simpa only [Function.comp_def,continuousMultilinearCurryFin0_apply,ContinuousMultilinearMap.curry0_apply,iteratedFDeriv_zero_apply] using hh |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology |
| namespace ThreeTorus |
|
|
| lemma continuous_tripleProject : Continuous tripleProject := by |
| change Continuous (fun x : Cover => ((x 0:UnitAddCircle),(x 1:UnitAddCircle),(x 2:UnitAddCircle))) |
| exact ((AddCircle.continuous_mk' 1).comp (continuous_apply 0)).prodMk |
| (((AddCircle.continuous_mk' 1).comp (continuous_apply 1)).prodMk |
| ((AddCircle.continuous_mk' 1).comp (continuous_apply 2))) |
|
|
| lemma circle_dist_coe_le (x y : ℝ) : dist (x:UnitAddCircle) (y:UnitAddCircle) ≤ dist x y := by |
| rw [dist_eq_norm,dist_eq_norm,← AddCircle.coe_sub] |
| exact QuotientAddGroup.norm_mk_le_norm |
|
|
| lemma tripleProject_dist_le (x y : Cover) : dist (tripleProject x) (tripleProject y) ≤ dist x y := by |
| change max (dist (x 0:UnitAddCircle) (y 0:UnitAddCircle)) |
| (max (dist (x 1:UnitAddCircle) (y 1:UnitAddCircle)) (dist (x 2:UnitAddCircle) (y 2:UnitAddCircle))) ≤ _ |
| exact max_le ((circle_dist_coe_le _ _).trans (dist_le_pi_dist x y 0)) |
| (max_le ((circle_dist_coe_le _ _).trans (dist_le_pi_dist x y 1)) |
| ((circle_dist_coe_le _ _).trans (dist_le_pi_dist x y 2))) |
|
|
| def tripleSection (z : TripleTorus) : Cover := |
| ![circleRep 0 z.1,circleRep 0 z.2.1,circleRep 0 z.2.2] |
| lemma tripleProject_section (z : TripleTorus) : tripleProject (tripleSection z)=z := by |
| change ((circleRep 0 z.1:UnitAddCircle),(circleRep 0 z.2.1:UnitAddCircle),(circleRep 0 z.2.2:UnitAddCircle))=z |
| simp only [coe_circleRep] |
| lemma tripleSection_norm (z : TripleTorus) : ‖tripleSection z‖ ≤ 1 := by |
| apply pi_norm_le_iff_of_nonneg zero_le_one |>.2 |
| intro i |
| have h (w : UnitAddCircle) : ‖circleRep 0 w‖ ≤ 1 := by |
| have hw := ((AddCircle.measurableEquivIoc 1 0) w).2 |
| change 0 < circleRep 0 w ∧ circleRep 0 w ≤ 0+1 at hw |
| simpa only [Real.norm_eq_abs,abs_of_pos hw.1,zero_add] using hw.2 |
| fin_cases i <;> exact h _ |
|
|
| /-- Local uniform cover convergence, plus the exact graph equations, descends |
| uniformly on the compact torus. The section is only a proof device; no |
| continuity of the measurable representatives is asserted. -/ |
| lemma descend_uniform_limit (f : ℕ → Cover → Cover) (g : Cover → Cover) |
| (F : ℕ → TripleTorus → TripleTorus) |
| (hg : TendstoLocallyUniformly f g atTop) |
| (hgraph : ∀ n x, tripleProject (f n x) = F n (tripleProject x)) : |
| TendstoUniformly F (fun z => tripleProject (g (tripleSection z))) atTop := by |
| have hc : IsCompact (Metric.closedBall (0:Cover) 1) := isCompact_closedBall _ _ |
| have hu := (tendstoLocallyUniformly_iff_forall_isCompact.mp hg) _ hc |
| apply Metric.tendstoUniformly_iff.mpr |
| intro ε hε |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu ε hε] with n hn |
| intro z |
| have hz : tripleSection z ∈ Metric.closedBall (0:Cover) 1 := by |
| simpa only [Metric.mem_closedBall,dist_zero_right] using tripleSection_norm z |
| have hh := (tripleProject_dist_le (g (tripleSection z)) (f n (tripleSection z))).trans_lt (hn _ hz) |
| simpa only [hgraph,tripleProject_section] using hh |
|
|
| lemma descend_limit_graph (f : ℕ → Cover → Cover) (g : Cover → Cover) |
| (F : ℕ → TripleTorus → TripleTorus) |
| (hg : TendstoLocallyUniformly f g atTop) |
| (hgraph : ∀ n x, tripleProject (f n x) = F n (tripleProject x)) (x : Cover) : |
| tripleProject (g (tripleSection (tripleProject x))) = tripleProject (g x) := by |
| have h₁ := (descend_uniform_limit f g F hg hgraph).tendsto_at (tripleProject x) |
| have h₂ := continuous_tripleProject.continuousAt.tendsto.comp (((tendstoLocallyUniformly_iff_forall_isCompact.mp hg) {x} (isCompact_singleton)).tendsto_at (mem_singleton x)) |
| have he : (fun n => tripleProject (f n x)) = (fun n => F n (tripleProject x)) := by |
| funext n; exact hgraph n x |
| change Tendsto (fun n => tripleProject (f n x)) atTop (𝓝 (tripleProject (g x))) at h₂ |
| rw [he] at h₂ |
| exact tendsto_nhds_unique h₁ h₂ |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators |
| namespace ThreeTorus |
|
|
| def jetIndices (N : ℕ) : Finset (ℤ × ℕ) := |
| (Finset.Icc (-(N:ℤ)) N).product (Finset.range (N+1)) |
|
|
| def jetExhaustion (N : ℕ) : PhysicalJetData where |
| size := Fintype.card ↥(jetIndices N) |
| sign i := ((Fintype.equivFin ↥(jetIndices N)).symm i).val.1 |
| order i := ((Fintype.equivFin ↥(jetIndices N)).symm i).val.2 |
| domain _ := Metric.closedBall (0:Cover) (N+1) |
| compact _ := isCompact_closedBall _ _ |
|
|
| lemma mem_jetIndices {N : ℕ} {k : ℤ} {d : ℕ} : |
| (k,d) ∈ jetIndices N ↔ k.natAbs ≤ N ∧ d ≤ N := by |
| simp only [jetIndices,Finset.product_eq_sprod,Finset.mem_product,Finset.mem_Icc,Finset.mem_range] |
| omega |
|
|
| lemma jetExhaustion_close_iff {N : ℕ} {ε : ℝ} {F G : PhysicalFrame} {V W : ℝ → ℝ} : |
| (jetExhaustion N).Close ε F V G W ↔ |
| ∀ k : ℤ, k.natAbs ≤ N → ∀ d : ℕ, d ≤ N → ∀ x : Cover, ‖x‖ ≤ (N:ℝ)+1 → |
| dist (iteratedFDeriv ℝ d (G.mapLift W k) x) |
| (iteratedFDeriv ℝ d (F.mapLift V k) x) ≤ ε := by |
| constructor |
| · intro h k hk d hd x hx |
| let j : ↥(jetIndices N) := ⟨(k,d),mem_jetIndices.mpr ⟨hk,hd⟩⟩ |
| let P (q : ℤ × ℕ) : Prop := ∀ y : Cover, ‖y‖ ≤ (N:ℝ)+1 → |
| dist (iteratedFDeriv ℝ q.2 (G.mapLift W q.1) y) |
| (iteratedFDeriv ℝ q.2 (F.mapLift V q.1) y) ≤ ε |
| have hh : P (((Fintype.equivFin ↥(jetIndices N)).symm |
| ((Fintype.equivFin ↥(jetIndices N)) j)).val) := by |
| intro y hy |
| exact h _ y (by simpa only [jetExhaustion,Metric.mem_closedBall,dist_zero_right] using hy) |
| have he : ((Fintype.equivFin ↥(jetIndices N)).symm |
| ((Fintype.equivFin ↥(jetIndices N)) j)).val = (k,d) := |
| congrArg Subtype.val ((Fintype.equivFin ↥(jetIndices N)).symm_apply_apply j) |
| exact (Eq.mp (congrArg P he) hh) x hx |
| · intro h i x hx |
| let j := (Fintype.equivFin ↥(jetIndices N)).symm i |
| have hj := mem_jetIndices.mp j.property |
| exact h j.val.1 hj.1 j.val.2 hj.2 x |
| (by simpa only [jetExhaustion,Metric.mem_closedBall,dist_zero_right] using hx) |
|
|
| lemma jetExhaustion_mono {M N : ℕ} (hMN : M ≤ N) {ε : ℝ} |
| {F G : PhysicalFrame} {V W : ℝ → ℝ} |
| (h : (jetExhaustion N).Close ε F V G W) : |
| (jetExhaustion M).Close ε F V G W := by |
| rw [jetExhaustion_close_iff] at h ⊢ |
| intro k hk d hd x hx |
| exact h k (hk.trans hMN) d (hd.trans hMN) x |
| (hx.trans (by exact_mod_cast Nat.add_le_add_right hMN 1)) |
|
|
| namespace StageState |
|
|
| def mapCont (s : StageState) (k : ℤ) : C(TripleTorus,TripleTorus) := |
| ⟨s.mapPow k,s.mapPow_cont k⟩ |
|
|
| lemma mapCont_dist_of_jets {s t : StageState} {N : ℕ} {ε : ℝ} (hε : 0 ≤ ε) |
| (hj : (jetExhaustion N).Close ε s.frame s.V t.frame t.V) |
| {k : ℤ} (hk : k.natAbs ≤ N) : dist (mapCont s k) (mapCont t k) ≤ ε := by |
| apply (ContinuousMap.dist_le hε).mpr |
| intro z |
| have hx : ‖tripleSection z‖ ≤ (N:ℝ)+1 := |
| (tripleSection_norm z).trans (le_add_of_nonneg_left (Nat.cast_nonneg N)) |
| have hh := jetExhaustion_close_iff.mp hj k hk 0 (Nat.zero_le _) (tripleSection z) hx |
| have h0 (F : Cover → Cover) : |
| (continuousMultilinearCurryFin0 ℝ Cover Cover) (iteratedFDeriv ℝ 0 F (tripleSection z)) = |
| F (tripleSection z) := by simp |
| have hd := (continuousMultilinearCurryFin0 ℝ Cover Cover).dist_map |
| (iteratedFDeriv ℝ 0 (t.frame.mapLift t.V k) (tripleSection z)) |
| (iteratedFDeriv ℝ 0 (s.frame.mapLift s.V k) (tripleSection z)) |
| rw [h0,h0] at hd |
| rw [← hd] at hh |
| have he := (tripleProject_dist_le _ _).trans hh |
| change dist (s.mapPow k z) (t.mapPow k z) ≤ ε |
| simpa only [t.mapPow_graph,s.mapPow_graph,tripleProject_section,dist_comm] using he |
|
|
| end StageState |
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology |
| namespace ThreeTorus |
|
|
| instance tripleVolume_regular : tripleVolume.Regular := |
| Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure tripleVolume |
|
|
| /-- Volume invariance is closed under uniform convergence of continuous maps |
| on the actual compact torus. No invertibility of the limit is assumed here. -/ |
| lemma measurePreserving_uniform_limit {F : ℕ → C(TripleTorus,TripleTorus)} |
| {G : C(TripleTorus,TripleTorus)} (hG : Tendsto F atTop (𝓝 G)) |
| (hF : ∀ n, MeasurePreserving (F n) tripleVolume tripleVolume) : |
| MeasurePreserving G tripleVolume tripleVolume := by |
| let : (Measure.map G tripleVolume).Regular := |
| Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure _ |
| refine ⟨G.continuous.measurable,?_⟩ |
| apply Measure.ext_of_integral_eq_on_compactlySupported |
| intro f |
| have ht : Tendsto (fun n => ∫ x, f (F n x) ∂tripleVolume) atTop |
| (𝓝 (∫ x, f (G x) ∂tripleVolume)) := by |
| apply tendsto_integral_of_dominated_convergence (fun _ => ‖f.toContinuousMap‖) |
| · intro n |
| exact (f.continuous.comp (F n).continuous).aestronglyMeasurable |
| · exact integrable_const _ |
| · intro n |
| exact ae_of_all _ (fun x => f.toContinuousMap.norm_coe_le_norm (F n x)) |
| · exact ae_of_all _ (fun x => f.continuous.continuousAt.tendsto.comp (hG.eval_const x)) |
| have hconst (n : ℕ) : (∫ x, f (F n x) ∂tripleVolume)=∫ x, f x ∂tripleVolume := by |
| change (∫ x, f.toContinuousMap (F n x) ∂tripleVolume)=∫ x, f.toContinuousMap x ∂tripleVolume |
| rw [← integral_map (hF n).measurable.aemeasurable f.continuous.aestronglyMeasurable,(hF n).map_eq] |
| simp only [hconst] at ht |
| change (∫ x, f.toContinuousMap x ∂Measure.map G tripleVolume)=∫ x, f.toContinuousMap x ∂tripleVolume |
| rw [integral_map G.continuous.measurable.aemeasurable f.continuous.aestronglyMeasurable] |
| exact tendsto_nhds_unique ht tendsto_const_nhds |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| end OAI |
|
|
