| import OAI.Dynamics.ThreeTorus.SmoothLimits |
|
|
| namespace OAI |
|
|
| /-! Stage topology, genuine smooth limiting dynamics, initial stage, unconditional diagonal, and limiting moments. -/ |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators |
| namespace ThreeTorus |
| namespace StageState |
|
|
| def coordinate (s : StageState) : L2 × (ℤ → C(TripleTorus,TripleTorus)) := |
| (s.vec,s.mapCont) |
| instance : TopologicalSpace StageState := TopologicalSpace.induced coordinate inferInstance |
|
|
| lemma continuous_coordinate : Continuous coordinate := continuous_induced_dom |
| lemma continuous_vec : Continuous (fun s : StageState => s.vec) := continuous_coordinate.fst |
| lemma continuous_mapCont (k : ℤ) : Continuous (fun s : StageState => s.mapCont k) := |
| (continuous_apply k).comp continuous_coordinate.snd |
| lemma continuous_orbit (k : ℤ) : Continuous (fun s : StageState => s.orbit k) := |
| continuous_vec.compMeasurePreservingLp (continuous_mapCont k) (fun s => s.mapPow_mp k) (by norm_num) |
| lemma continuous_laurent (c : ℤ →₀ ℂ) : Continuous (fun s : StageState => s.laurent c) := by |
| classical |
| exact continuous_finsetSum _ (fun k _ => (continuous_orbit k).const_smul (c k)) |
|
|
| /-- Finite jets and a physical vector tolerance reach every neighborhood needed |
| for retaining previously chosen Laurent polynomials. -/ |
| lemma finite_neighborhood_control (s : StageState) {U : Set StageState} (hU : U ∈ 𝓝 s) : |
| ∃ N : ℕ, ∃ ε > 0, ∀ t : StageState, |
| dist s.vec t.vec < ε → (jetExhaustion N).Close ε s.frame s.V t.frame t.V → t ∈ U := by |
| classical |
| by_contra hh |
| push Not at hh |
| have hp (n : ℕ) : 0 < (1/2:ℝ)^n := pow_pos (by norm_num) _ |
| choose t hvt hjt hut using fun n => hh n ((1/2:ℝ)^n) (hp n) |
| have hz : Tendsto (fun n : ℕ => (1/2:ℝ)^n) atTop (𝓝 0) := |
| tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) (by norm_num) |
| have hv : Tendsto (fun n => (t n).vec) atTop (𝓝 s.vec) := by |
| apply Metric.tendsto_atTop.mpr |
| intro ε hε |
| obtain ⟨N,hN⟩ := eventually_atTop.mp (hz.eventually (gt_mem_nhds hε)) |
| exact ⟨N,fun n hn => by simpa only [dist_comm] using (hvt n).trans (hN n hn)⟩ |
| have hm (k : ℤ) : Tendsto (fun n => (t n).mapCont k) atTop (𝓝 (s.mapCont k)) := by |
| apply Metric.tendsto_atTop.mpr |
| intro ε hε |
| obtain ⟨N,hN⟩ := eventually_atTop.mp (hz.eventually (gt_mem_nhds hε)) |
| refine ⟨max N k.natAbs,fun n hn => ?_⟩ |
| have hh' := mapCont_dist_of_jets (hp n).le (hjt n) (le_trans (le_max_right _ _) hn) |
| have hh'' : dist ((t n).mapCont k) (s.mapCont k) ≤ (1/2:ℝ)^n := by |
| simpa only [dist_comm] using hh' |
| exact hh''.trans_lt (hN n (le_trans (le_max_left _ _) hn)) |
| have ht : Tendsto t atTop (𝓝 s) := by |
| apply (Topology.IsInducing.induced coordinate).tendsto_nhds_iff.mpr |
| exact hv.prodMk_nhds (tendsto_pi_nhds.mpr hm) |
| obtain ⟨n,hn⟩ := (ht.eventually hU).exists |
| exact hut n hn |
|
|
| end StageState |
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ContDiff |
| namespace ThreeTorus |
|
|
| lemma smooth_diagonal_eventual_jets (f : ℕ → Cover → Cover) |
| (hf : ∀ n, ContDiff ℝ ∞ (f n)) {b : ℕ → ℝ} (hb : Summable b) |
| (hstep : ∀ (d : ℕ) (R : ℝ), ∀ᶠ n in atTop, ∀ x : Cover, ‖x‖ ≤ R → |
| dist (iteratedFDeriv ℝ d (f (n+1)) x) (iteratedFDeriv ℝ d (f n) x) ≤ b n) : |
| ∃ g : Cover → Cover, ContDiff ℝ ∞ g ∧ TendstoLocallyUniformly f g 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:Cover) |
| apply uniform_incrementLimit _ hb |
| filter_upwards [hstep d R] with n hn |
| intro x hx |
| exact hn x (by simpa only [Metric.mem_closedBall,dist_zero_right] using hR hx) |
| refine ⟨fun x => (q 0 x).curry0,smooth_of_jet_limits f hf q hq,?_⟩ |
| have hh := (continuousMultilinearCurryFin0 ℝ Cover Cover).isometry.uniformContinuous.comp_tendstoLocallyUniformly (hq 0) |
| simpa only [Function.comp_def,continuousMultilinearCurryFin0_apply,ContinuousMultilinearMap.curry0_apply,iteratedFDeriv_zero_apply] using hh |
|
|
| /-- An actual smooth, volume preserving integer action on the physical torus. |
| This is limit DATA constructed below, not an assumption on a stage. -/ |
| structure SmoothDynamics where |
| map : ℤ → C(TripleTorus,TripleTorus) |
| zero : ∀ x, map 0 x=x |
| add : ∀ k j x, map (k+j) x=map k (map j x) |
| mp : ∀ k, MeasurePreserving (map k) tripleVolume tripleVolume |
| lift : ℤ → Cover → Cover |
| smooth : ∀ k, ContDiff ℝ ∞ (lift k) |
| graph : ∀ k x, tripleProject (lift k x)=map k (tripleProject x) |
|
|
| /-- Mere summable finite jet changes suffice for the genuine smooth action, |
| including the inverse and standard volume; every fixed integer power is kept. -/ |
| theorem smooth_dynamics_of_jets (s : ℕ → StageState) {b : ℕ → ℝ} (hb : Summable b) |
| (hj : ∀ n, (jetExhaustion n).Close (b n) (s n).frame (s n).V (s (n+1)).frame (s (n+1)).V) : |
| ∃ D : SmoothDynamics, ∀ k : ℤ, Tendsto (fun n => (s n).mapCont k) atTop (𝓝 (D.map k)) := by |
| have hh (k : ℤ) : ∃ g : Cover → Cover, ContDiff ℝ ∞ g ∧ |
| TendstoLocallyUniformly (fun n => (s n).frame.mapLift (s n).V k) g atTop := by |
| apply smooth_diagonal_eventual_jets _ (fun n => (s n).frame.mapLift_smooth (s n).smooth k) hb |
| intro d R |
| obtain ⟨N,hN⟩ := exists_nat_ge R |
| filter_upwards [eventually_ge_atTop (max N (max k.natAbs d))] with n hn |
| intro x hx |
| apply jetExhaustion_close_iff.mp (hj n) k (by omega) d (by omega) x |
| have hNn : (N:ℝ) ≤ n := by exact_mod_cast (show N ≤ n by omega) |
| linarith |
| choose G hGs hGc using hh |
| have hu (k : ℤ) := descend_uniform_limit _ (G k) (fun n => (s n).mapPow k) (hGc k) |
| (fun n => (s n).mapPow_graph k) |
| let T (k : ℤ) : C(TripleTorus,TripleTorus) := |
| ⟨fun z => tripleProject (G k (tripleSection z)), |
| (hu k).continuous ((Eventually.of_forall (fun n => (s n).mapPow_cont k)).frequently)⟩ |
| have hT (k : ℤ) : Tendsto (fun n => (s n).mapCont k) atTop (𝓝 (T k)) := |
| ContinuousMap.tendsto_iff_tendstoUniformly.mpr (hu k) |
| have h0 (x : TripleTorus) : T 0 x=x := by |
| have hh := (hT 0).eval_const x |
| have he (n : ℕ) : (s n).mapCont 0 x=x := (s n).mapPow_zero x |
| simp only [he] at hh |
| exact tendsto_nhds_unique hh tendsto_const_nhds |
| have hadd (k j : ℤ) (x : TripleTorus) : T (k+j) x=T k (T j x) := by |
| have h₁ := (hT (k+j)).eval_const x |
| have h₂ := (hT k).eval ((hT j).eval_const x) |
| have he : (fun n => (s n).mapCont (k+j) x)= |
| (fun n => (s n).mapCont k ((s n).mapCont j x)) := by |
| funext n; exact (s n).mapPow_add k j x |
| rw [he] at h₁ |
| exact tendsto_nhds_unique h₁ h₂ |
| refine ⟨{ |
| map := T, zero := h0, add := hadd, |
| mp := fun k => measurePreserving_uniform_limit (hT k) (fun n => (s n).mapPow_mp k), |
| lift := G, smooth := hGs, |
| graph := fun k x => (descend_limit_graph _ _ _ (hGc k) (fun n => (s n).mapPow_graph k) x).symm },hT⟩ |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate ENNReal |
| namespace ThreeTorus |
|
|
| /-- Starting the actual construction needs no dynamical oracle: two reflected |
| angular packets on a single affine good arc have exactly Haar spectrum. -/ |
| theorem exists_initial_stage {δ : ℝ} (hδ : 0 < δ) (hδ' : δ < 1/8) : |
| ∃ s : StageState, s.δ = δ := by |
| let cut := lawCutoffs δ hδ hδ' |
| let V := neutralJitterReal cut 1 0 |
| let p := neutralJitterReal_periodic cut 1 0 |
| let φ := p.lift |
| have hs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V := neutralJitterReal_smooth cut 1 0 |
| have hc : Continuous φ := continuous_neutralJitter cut 1 0 |
| have hv (x : ℝ) (hx : x ∈ Icc (1/4:ℝ) (3/4)) : φ (x:UnitAddCircle)=x := by |
| change V x=x |
| simpa only [one_mul,add_zero] using neutralJitterReal_affine cut hδ 1 0 |
| (a := x) (show x ∈ Icc δ (1-δ) by constructor <;> linarith [hx.1,hx.2]) |
| have hd (x : ℝ) (hx : x ∈ Icc (1/4:ℝ) (3/4)) : |
| HasDerivWithinAt (fun y : ℝ => φ (y:UnitAddCircle)) 1 (Icc (1/4:ℝ) (3/4)) x := by |
| have he : deriv V x=1 := neutralJitterReal_deriv cut hδ 1 0 |
| (show x ∈ Ioo δ (1-δ) by constructor <;> linarith [hx.1,hx.2]) |
| change HasDerivWithinAt V 1 _ x |
| rw [← he] |
| exact ((hs.differentiable (by simp)).differentiableAt.hasDerivAt).hasDerivWithinAt |
| obtain ⟨m,_,hm,t,ht,hlt,hA,hAL,hAr,hp,hn,hAs⟩ := exists_flat_packet_spectra_above |
| hc.measurable (measurable_const : Measurable (fun _ : ℝ => (1:ℝ))) |
| (show (1/4:ℝ)<3/4 by norm_num) hd |
| (by intro x hx y hy hxy; simpa only [hv x hx,hv y hy] using hxy) |
| (show Icc (1/4:ℝ) (3/4) ⊆ Ioc (0:ℝ) (0+1) by intro x hx; constructor <;> linarith [hx.1,hx.2]) 0 |
| let A := fun ua : UnitAddCircle × UnitAddCircle => |
| flatAmplitude 0 (1/4) t (fun _ => (m:ℝ)*1) ua.1 |
| have hmz : (m:ℤ) ≠ 0 := by exact_mod_cast (ne_of_gt hm) |
| let F : MeasurablePackets := { |
| Index := Bool, finite := inferInstance, |
| m := fun b => if b then (m:ℤ) else -(m:ℤ), |
| injective := by intro b c h; cases b <;> cases c <;> simp_all, |
| nonzero := by intro b; cases b <;> simpa using hmz, |
| A := fun _ => A, measurable := fun _ => hA, memLp := fun _ => hAL } |
| have hr : F.Reflection Bool.not := by |
| refine ⟨(by intro b; cases b <;> rfl),?_,?_⟩ |
| · intro b; cases b <;> simp [F] |
| · intro b ua; exact (hAr ua).symm |
| have hflat : F.spectrum (fun z => (φ z:UnitAddCircle))=phaseHaar := by |
| change (∑ b : Bool, packetSpectralMeasure (fun z => (φ z:UnitAddCircle)) |
| (if b then (m:ℤ) else -(m:ℤ)) A)=phaseHaar |
| simp only [A,Fintype.sum_bool,Bool.false_eq_true,ite_false,ite_true,hp,hn,← add_smul] |
| rw [← ENNReal.ofReal_add (by norm_num) (by norm_num)] |
| norm_num |
| have hsupport : F.Supported (1/4) (3/4) := by |
| intro b ua hua |
| obtain ⟨x,hx,hxe⟩ := (hAs hua).1 |
| exact ⟨⟨x,⟨hx.1,hx.2.trans ht.2⟩,hxe⟩,mem_univ _⟩ |
| refine ⟨{ |
| frame := PhysicalFrame.ident, |
| chart_cont := continuous_id, |
| chart_mp := MeasurePreserving.id _, |
| packets := F, reflected := ⟨Bool.not,hr⟩, |
| V := V, periodic := p, smooth := hs, |
| δ := δ, l := 1/4, u := 3/4, δ_pos := hδ, δ_half := by linarith, |
| δ_l := by linarith, l_u := by norm_num, u_δ := by linarith, |
| increasing := by intro x hx; rw [neutralJitterReal_deriv cut hδ 1 0 hx]; norm_num, |
| supported := hsupport, flat := hflat },rfl⟩ |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators |
| namespace ThreeTorus |
|
|
| /-- The finite history is kept at every successor; no density or limit is |
| part of this bookkeeping data. -/ |
| structure StageHistory (test : ℕ → PhysicalTest) (e : ℕ → ℝ) (n : ℕ) where |
| stage : StageState |
| coeff : ℕ → (ℤ →₀ ℂ) |
| small : stage.δ < (e n)^2/8 |
| retained : ∀ i < n, dist (test i).vec (stage.laurent (coeff i)) < e i |
|
|
| namespace StageHistory |
| variable {test : ℕ → PhysicalTest} {e : ℕ → ℝ} (he : ∀ n, 0 < e n) |
| include he |
|
|
| lemma exists_start : Nonempty (StageHistory test e 0) := by |
| let δ := min ((e 0)^2/16) (1/16:ℝ) |
| have hδ : 0 < δ := lt_min (div_pos (sq_pos_of_pos (he 0)) (by norm_num)) (by norm_num) |
| obtain ⟨s,hs⟩ := exists_initial_stage hδ (lt_of_le_of_lt (min_le_right _ _) (by norm_num)) |
| refine ⟨⟨s,fun _ => 0,?_,by omega⟩⟩ |
| rw [hs] |
| have hh := min_le_left ((e 0)^2/16) (1/16:ℝ) |
| have hp := sq_pos_of_pos (he 0) |
| dsimp [δ] at * |
| linarith |
|
|
| lemma exists_next {n : ℕ} (a : StageHistory test e n) {b : ℝ} (hb : 0 < b) : |
| ∃ t : StageHistory test e (n+1), |
| (∀ i < n, t.coeff i=a.coeff i) ∧ |
| dist a.stage.vec t.stage.vec < b ∧ |
| (jetExhaustion n).Close b a.stage.frame a.stage.V t.stage.frame t.stage.V := by |
| classical |
| let U : Set StageState := {s | ∀ i : Fin n, |
| dist (test i).vec (s.laurent (a.coeff i)) < e i} |
| have hUo : IsOpen U := by |
| have hUeq : U = ⋂ i : Fin n, {s : StageState | dist (test i).vec (s.laurent (a.coeff i)) < e i} := by |
| ext s; simp only [U,mem_ofPred_eq,mem_iInter] |
| rw [hUeq] |
| exact isOpen_iInter_of_finite (fun i => isOpen_lt |
| (continuous_const.dist (StageState.continuous_laurent (a.coeff i))) continuous_const) |
| have hUa : a.stage ∈ U := fun i => a.retained i i.isLt |
| obtain ⟨N,ε,hε,hcontrol⟩ := a.stage.finite_neighborhood_control (hUo.mem_nhds hUa) |
| let z := min b (ε/2) |
| have hz : 0 < z := lt_min hb (half_pos hε) |
| obtain ⟨s,c,hsδ,hjs,hvs,hcs⟩ := a.stage.exists_step (test n) |
| (jetExhaustion (max n N)) (ε := z) (η := e n/2) (κ := (e (n+1))^2/8) (ζ := z) hz (half_pos (he n)) |
| (div_pos (sq_pos_of_pos (he (n+1))) (by norm_num)) hz |
| have hsU : s ∈ U := hcontrol s |
| (hvs.trans_le ((min_le_right _ _).trans (by linarith))) |
| ((jetExhaustion_mono (le_max_right n N) hjs).mono |
| ((min_le_right _ _).trans (by linarith))) |
| have hsq : Real.sqrt (2*a.stage.δ) < e n/2 := by |
| apply (Real.sqrt_lt' (half_pos (he n))).mpr |
| nlinarith [a.small] |
| let t : StageHistory test e (n+1) := { |
| stage := s, |
| coeff := Function.update a.coeff n c, |
| small := hsδ, |
| retained := by |
| intro i hi |
| by_cases hin : i=n |
| · subst i |
| simp only [Function.update_self] |
| exact hcs.trans (by linarith) |
| · rw [Function.update_of_ne hin] |
| exact hsU ⟨i,by omega⟩ } |
| refine ⟨t,?_,hvs.trans_le (min_le_left _ _), |
| (jetExhaustion_mono (le_max_left n N) hjs).mono (min_le_left _ _)⟩ |
| intro i hi |
| exact Function.update_of_ne (by omega : i ≠ n) c a.coeff |
| |
| end StageHistory |
| |
| /-- A literal diagonal of actual stage states with simultaneously retained |
| finite polynomials. Only the externally selected real tests occur in the input; |
| all dynamics, packets and coefficient choices are produced by the stage. -/ |
| theorem exists_stage_diagonal (test : ℕ → PhysicalTest) (e b : ℕ → ℝ) |
| (he : ∀ n, 0 < e n) (hb : ∀ n, 0 < b n) : |
| ∃ s : ℕ → StageState, ∃ c : ℕ → (ℤ →₀ ℂ), |
| (∀ n, dist (s n).vec (s (n+1)).vec < b n) ∧ |
| (∀ n, (jetExhaustion n).Close (b n) (s n).frame (s n).V |
| (s (n+1)).frame (s (n+1)).V) ∧ |
| (∀ i n, i < n → dist (test i).vec ((s n).laurent (c i)) < e i) := by |
| classical |
| let next {n : ℕ} (a : StageHistory test e n) : StageHistory test e (n+1) := |
| Classical.choose (a.exists_next he (hb n)) |
| have hn {n : ℕ} (a : StageHistory test e n) := |
| Classical.choose_spec (a.exists_next he (hb n)) |
| let a : (n : ℕ) → StageHistory test e n := |
| fun n => Nat.rec (Classical.choice (StageHistory.exists_start (test := test) he)) |
| (fun _ an => next an) n |
| have has (n : ℕ) : a (n+1)=next (a n) := rfl |
| have hc (i n : ℕ) (hin : i<n) : (a n).coeff i=(a (i+1)).coeff i := by |
| induction n with |
| | zero => omega |
| | succ n ih => |
| by_cases h : i=n |
| · subst i; rfl |
| · rw [has,(hn (a n)).1 i (by omega)] |
| exact ih (by omega) |
| refine ⟨fun n => (a n).stage,fun i => (a (i+1)).coeff i,?_,?_,?_⟩ |
| · intro n; exact (hn (a n)).2.1 |
| · intro n; exact (hn (a n)).2.2 |
| · intro i n hin |
| change dist (test i).vec ((a n).stage.laurent ((a (i+1)).coeff i)) < e i |
| rw [← hc i n hin] |
| exact (a n).retained i hin |
| |
| end ThreeTorus |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
| namespace StageState |
| variable (s : StageState) |
| |
| lemma orbit_zero : s.orbit 0=s.vec := by |
| apply Lp.ext |
| filter_upwards [s.orbit_ae 0,s.vec_ae] with x hx hy |
| simpa only [s.mapPow_zero,hy] using hx |
| |
| lemma orbit_comp (k j : ℤ) : |
| Lp.compMeasurePreserving (s.mapPow j) (s.mapPow_mp j) (s.orbit k)=s.orbit (k+j) := by |
| apply Lp.ext |
| filter_upwards [Lp.coeFn_compMeasurePreserving (s.orbit k) (s.mapPow_mp j), |
| (s.mapPow_mp j).quasiMeasurePreserving.ae (s.orbit_ae k),s.orbit_ae (k+j)] with x hx hy hz |
| simpa only [Function.comp_apply,hy,hz,s.mapPow_add] using hx |
| |
| lemma inner_vec_orbit (k : ℤ) : inner ℂ s.vec (s.orbit k)=if k=0 then 1 else 0 := by |
| rw [L2.inner_def] |
| have he : (fun x => inner ℂ (s.vec x) (s.orbit k x)) =ᵐ[tripleVolume] |
| fun x => conj (s.packets.vector (s.frame.chart x))* |
| s.packets.vector (twistIter s.speed k (s.frame.chart x)) := by |
| filter_upwards [s.vec_ae,s.orbit_ae k] with x hx hy |
| rw [hx,hy] |
| simp only [vector,mapPow_apply,Function.comp_apply,s.frame.chart.apply_symm_apply, |
| RCLike.inner_apply,mul_comm] |
| rw [integral_congr_ae he, |
| s.chart_mp.integral_comp s.chartHomeo.toMeasurableEquiv.measurableEmbedding |
| (g := fun x => conj (s.packets.vector x)*s.packets.vector (twistIter s.speed k x))] |
| exact s.packets.flat_moment s.speed_cont.measurable s.flat k |
| |
| lemma orbit_orthonormal : Orthonormal ℂ s.orbit := by |
| rw [orthonormal_iff_ite] |
| intro k j |
| have hh := (Lp.compMeasurePreservingₗᵢ ℂ (s.mapPow k) (s.mapPow_mp k)).inner_map_map |
| s.vec (s.orbit (j-k)) |
| change inner ℂ (s.orbit k) |
| (Lp.compMeasurePreserving (s.mapPow k) (s.mapPow_mp k) (s.orbit (j-k))) = _ at hh |
| rw [s.orbit_comp,sub_add_cancel,s.inner_vec_orbit] at hh |
| simpa only [sub_eq_zero,eq_comm] using hh |
| |
| lemma vec_norm : ‖s.vec‖=1 := by |
| have hh := s.orbit_orthonormal.norm_eq_one 0 |
| rwa [s.orbit_zero] at hh |
| |
| end StageState |
| end ThreeTorus |
| end |
| end |
| |
| end OAI |
| |
