Download data/lean/OAI/Dynamics/StandardMap/Stable/PerronStability.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 37.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/StandardMap/Stable/PerronStability.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/StandardMap/Stable/PerronStability.lean
-
curl -L -o PerronStability.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/StandardMap/Stable/PerronStability.lean
37.4 kB
| import OAI.Dynamics.StandardMap.EntropyEndpoint | |
| import OAI.Dynamics.StandardMap.Stable.LocalStable | |
| namespace OAI | |
| section | |
| section | |
| namespace StandardMapEntropy.NonlinearStable | |
| open Filter | |
| open scoped Topology NNReal | |
| variable {β Ξ΄ : ββ₯0} | |
| lemma perron_defect_bound (r : Recurrence β Ξ΄) (hβ : ββ€1) (s : β) (x : Sequence) | |
| {B : β} (hB : 0β€B) (h0 : (x 0).1=s) | |
| (hstep : β n, βx (n+1)-r.step n (x n)ββ€B) : | |
| βr.perron hβ s x-xββ€B := by | |
| apply (BoundedContinuousFunction.norm_le hB).mpr | |
| intro n | |
| rw [Prod.norm_def] | |
| apply max_le | |
| Β· cases n with | |
| | zero => simpa only [BoundedContinuousFunction.sub_apply,perron_apply,Recurrence.perronValue, | |
| Prod.fst_sub,h0,sub_self,norm_zero] using hB | |
| | succ n => | |
| have hh := (norm_fst_le (x (n+1)-r.step n (x n))).trans (hstep n) | |
| change |r.a n*(x n).1+(r.remainder n (x n)).1-(x (n+1)).1|β€B | |
| rw [abs_sub_comm] | |
| exact hh | |
| Β· have hh := (norm_snd_le (x (n+1)-r.step n (x n))).trans (hstep n) | |
| change |(r.b n)β»ΒΉ*((x (n+1)).2-(r.remainder n (x n)).2)-(x n).2|β€B | |
| calc | |
| _ = |(r.b n)β»ΒΉ| * |(x (n+1)).2-(r.b n*(x n).2+(r.remainder n (x n)).2)| := by | |
| rw [βabs_mul] | |
| congr 1 | |
| have hb := inv_mul_cancelβ (r.b_ne n) | |
| calc | |
| _ = (r.b n)β»ΒΉ*((x (n+1)).2-(r.remainder n (x n)).2)- | |
| ((r.b n)β»ΒΉ*r.b n)*(x n).2 := by rw [hb,one_mul] | |
| _ = _ := by ring | |
| _ β€ (β : β)*B := mul_le_mul (r.inverse_bound n) hh (abs_nonneg _) β.coe_nonneg | |
| _ β€ B := (mul_le_mul_of_nonneg_right (show (β : β)β€1 from hβ) hB).trans_eq (one_mul _) | |
| lemma near_orbit_solution_bound (r : Recurrence β Ξ΄) (h : β+Ξ΄<1) (s : β) (x : Sequence) | |
| {B : β} (hB : 0β€B) (h0 : (x 0).1=s) | |
| (hstep : β n, βx (n+1)-r.step n (x n)ββ€B) : | |
| βx-r.solution h sββ€B/(1-((β+Ξ΄ : ββ₯0) : β)) := by | |
| have hh := (perron_contracting r h (s := s)).dist_fixedPoint_le x | |
| rw [dist_eq_norm,dist_eq_norm] at hh | |
| change βx-r.solution h sββ€_ at hh | |
| have hp := perron_defect_bound r (le_trans (le_add_of_nonneg_right (show (0 : ββ₯0)β€Ξ΄ from bot_le)) h.le) | |
| s x hB h0 hstep | |
| rw [norm_sub_rev] at hp | |
| exact hh.trans (div_le_div_of_nonneg_right hp (sub_nonneg.mpr (show ((β+Ξ΄ : ββ₯0) : β)β€1 from h.le))) | |
| noncomputable def LocalRecurrence.linearized (r : LocalRecurrence β Ξ΄) | |
| (D : β β Plane βL[β] Plane) (hD : β n, βD nββ€Ξ΄) : Recurrence β Ξ΄ where | |
| a := r.a | |
| b := r.b | |
| remainder n := D n | |
| stable_bound := r.stable_bound | |
| inverse_bound := r.inverse_bound | |
| b_ne := r.b_ne | |
| lipschitz n := LipschitzWith.of_dist_le_mul fun v w => by | |
| rw [dist_eq_norm,dist_eq_norm,βmap_sub] | |
| exact ((D n).le_opNorm (v-w)).trans (mul_le_mul_of_nonneg_right (hD n) (norm_nonneg _)) | |
| zero n := map_zero _ | |
| lemma linearized_step_smul (r : LocalRecurrence β Ξ΄) (D : β β Plane βL[β] Plane) | |
| (hD : β n, βD nββ€Ξ΄) (n : β) (t : β) (v : Plane) : | |
| (r.linearized D hD).step n (t β’ v)=t β’ (r.linearized D hD).step n v := by | |
| apply Prod.ext <;> simp only [LocalRecurrence.linearized,Recurrence.step,Prod.smul_fst,Prod.smul_snd, | |
| map_smul,smul_eq_mul] <;> ring | |
| lemma linearized_solution_smul (r : LocalRecurrence β Ξ΄) (D : β β Plane βL[β] Plane) | |
| (hD : β n, βD nββ€Ξ΄) (h : β+Ξ΄<1) (t : β) : | |
| (r.linearized D hD).solution h t=t β’ (r.linearized D hD).solution h 1 := by | |
| symm | |
| apply solution_unique | |
| Β· change (t β’ (r.linearized D hD).solution h 1 0).1=t | |
| rw [Prod.smul_fst,solution_initial,smul_eq_mul,mul_one] | |
| Β· intro n | |
| change t β’ (r.linearized D hD).solution h 1 (n+1)= | |
| (r.linearized D hD).step n (t β’ (r.linearized D hD).solution h 1 n) | |
| rw [solution_orbit,linearized_step_smul] | |
| lemma hasDerivAt_of_quadratic_bound {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| {f : β β E} {v : E} {x C : β} (hC : 0β€C) | |
| (h : βαΆ y in π x, βf y-f x-(y-x) β’ vββ€C*|y-x|^2) : HasDerivAt f v x := by | |
| rw [hasDerivAt_iff_isLittleO,Asymptotics.isLittleO_iff] | |
| intro Ξ΅ hΞ΅ | |
| have he : 0<Ξ΅/(C+1) := div_pos hΞ΅ (by linarith) | |
| have hsmall : βαΆ y in π x, |y-x|<Ξ΅/(C+1) := by | |
| filter_upwards [Metric.ball_mem_nhds x he] with y hy | |
| simpa only [Metric.mem_ball,Real.dist_eq] using hy | |
| filter_upwards [h,hsmall] with y hy hys | |
| rw [Real.norm_eq_abs] | |
| apply hy.trans | |
| have hb : C*|y-x|β€Ξ΅ := by | |
| have hh := (lt_div_iffβ (show 0<C+1 by linarith)).mp hys | |
| nlinarith [abs_nonneg (y-x)] | |
| calc | |
| _ = (C*|y-x|)*|y-x| := by ring | |
| _ β€ _ := mul_le_mul_of_nonneg_right hb (abs_nonneg _) | |
| end StandardMapEntropy.NonlinearStable | |
| end | |
| section | |
| namespace StandardMapEntropy | |
| open MeasureTheory Set Filter | |
| open scoped Topology NNReal ENNReal | |
| lemma quadratic_taylor_of_derivative_lipschitz {E F : Type*} | |
| [NormedAddCommGroup E] [NormedSpace β E] [NormedAddCommGroup F] [NormedSpace β F] | |
| (f : E β F) (D : E β E βL[β] F) (hD : β x, HasFDerivAt f (D x) x) | |
| {M : β} (hM : 0β€M) (hLip : β x y, βD x-D yββ€M*βx-yβ) (v w : E) : | |
| βf w-f v-D v (w-v)ββ€M*βw-vβ^2 := by | |
| let g : E β F := fun x => f x-f v-D v (x-v) | |
| have hg (x : E) : HasFDerivAt g (D x-D v) x := by | |
| have hh := ((hD x).sub_const (f v)).sub ((D v).hasFDerivAt.comp x ((hasFDerivAt_id x).sub_const v)) | |
| convert! hh using 1 | |
| have hlocal (x : E) (hx : xβMetric.closedBall v βw-vβ) : βD x-D vββ€M*βw-vβ := by | |
| refine (hLip x v).trans (mul_le_mul_of_nonneg_left ?_ hM) | |
| simpa only [Metric.mem_closedBall,dist_eq_norm] using hx | |
| have hh := (convex_closedBall v βw-vβ).norm_image_sub_le_of_norm_hasFDerivWithin_le | |
| (fun x _ => (hg x).hasFDerivWithinAt) hlocal | |
| (show vβMetric.closedBall v βw-vβ by simpa only [Metric.mem_closedBall,dist_self] using norm_nonneg (w-v)) | |
| (show wβMetric.closedBall v βw-vβ by simp only [Metric.mem_closedBall,dist_eq_norm,le_refl]) | |
| simpa only [g,sub_self,map_zero,sub_zero,pow_two,mul_assoc] using hh | |
| noncomputable def flatRemainderDerivative (k : β) (z : β) (F : RealPlane βL[β] β) | |
| (C : β βL[β] RealPlane) (v : RealPlane) : RealPlane βL[β] RealPlane := | |
| C.comp ((standardDerivative k (complexProjection (z+F v))-standardDerivative k (complexProjection z)).comp F) | |
| lemma hasFDerivAt_flatRemainder (k : β) (z : β) (F : RealPlane βL[β] β) | |
| (C : β βL[β] RealPlane) (v : RealPlane) : | |
| HasFDerivAt (flatRemainder k z F C) (flatRemainderDerivative k z F C v) v := by | |
| exact C.hasFDerivAt.comp v ((hasFDerivAt_liftRemainder k z (F v)).comp v F.hasFDerivAt) | |
| @[simp] lemma flatRemainderDerivative_zero (k : β) (z : β) (F : RealPlane βL[β] β) | |
| (C : β βL[β] RealPlane) : flatRemainderDerivative k z F C 0=0 := by | |
| simp only [flatRemainderDerivative,map_zero,add_zero,sub_self,ContinuousLinearMap.zero_comp,ContinuousLinearMap.comp_zero] | |
| lemma flatRemainderDerivative_lipschitz (k : β) (z : β) (F : RealPlane βL[β] β) | |
| (C : β βL[β] RealPlane) (v w : RealPlane) : | |
| βflatRemainderDerivative k z F C v-flatRemainderDerivative k z F C wββ€ | |
| (βCβ*derivativeVariationBound k*βFβ^2)*βv-wβ := by | |
| have he : flatRemainderDerivative k z F C v-flatRemainderDerivative k z F C w= | |
| C.comp ((standardDerivative k (complexProjection (z+F v))- | |
| standardDerivative k (complexProjection (z+F w))).comp F) := by | |
| apply ContinuousLinearMap.ext | |
| intro u | |
| simp only [flatRemainderDerivative,sub_apply,ContinuousLinearMap.comp_apply,map_sub] | |
| abel | |
| have hd := standardDerivative_lift_sub_bound k (z+F v) (z+F w) | |
| rw [add_sub_add_left_eq_sub,βmap_sub] at hd | |
| have hd' := hd.trans (mul_le_mul_of_nonneg_left (F.le_opNorm (v-w)) (derivativeVariationBound_nonneg k)) | |
| rw [he] | |
| calc | |
| _ β€ βCβ*β(standardDerivative k (complexProjection (z+F v))- | |
| standardDerivative k (complexProjection (z+F w))).comp Fβ := ContinuousLinearMap.opNorm_comp_le _ _ | |
| _ β€ βCβ*(βstandardDerivative k (complexProjection (z+F v))- | |
| standardDerivative k (complexProjection (z+F w))β*βFβ) := | |
| mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg C) | |
| _ β€ βCβ*((derivativeVariationBound k*(βFβ*βv-wβ))*βFβ) := | |
| mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right hd' (norm_nonneg F)) (norm_nonneg C) | |
| _ = _ := by ring | |
| noncomputable def actualChartRemainderDerivative (k Ο : β) (z : β) : RealPlane β RealPlane βL[β] RealPlane := | |
| flatRemainderDerivative k z (actualChartFrame k Ο (complexProjection z)) | |
| (actualChartInverse k Ο (standardMap k (complexProjection z))) | |
| lemma hasFDerivAt_actualChartRemainder (k Ο : β) (z : β) (v : RealPlane) : | |
| HasFDerivAt (actualChartRemainder k Ο z) (actualChartRemainderDerivative k Ο z v) v := | |
| hasFDerivAt_flatRemainder _ _ _ _ _ | |
| @[simp] lemma actualChartRemainderDerivative_zero (k Ο : β) (z : β) : actualChartRemainderDerivative k Ο z 0=0 := | |
| flatRemainderDerivative_zero _ _ _ _ | |
| lemma actualChartRemainderDerivative_lipschitz (k : β) {Ο : β} (hΟ : 0<Ο) (z : β) | |
| (hz : RegularChartPoint k Ο (complexProjection z)) | |
| (hn : RegularChartPoint k Ο (standardMap k (complexProjection z))) (v w : RealPlane) : | |
| βactualChartRemainderDerivative k Ο z v-actualChartRemainderDerivative k Ο z wββ€ | |
| hyperbolicChartError Ο*βv-wβ := | |
| (flatRemainderDerivative_lipschitz k z _ _ v w).trans | |
| (mul_le_mul_of_nonneg_right (chart_nonlinearity_coefficient k hΟ _ hz hn) (norm_nonneg _)) | |
| lemma actualChartRemainderDerivative_bound (k : β) {Ο : β} (hΟ : 0<Ο) (z : β) | |
| (hz : RegularChartPoint k Ο (complexProjection z)) | |
| (hn : RegularChartPoint k Ο (standardMap k (complexProjection z))) | |
| {v : RealPlane} (hv : βvββ€1) : βactualChartRemainderDerivative k Ο z vββ€hyperbolicChartError Ο := by | |
| have hh := actualChartRemainderDerivative_lipschitz k hΟ z hz hn v 0 | |
| simp only [actualChartRemainderDerivative_zero,sub_zero] at hh | |
| exact hh.trans ((mul_le_mul_of_nonneg_left hv (hyperbolicChartError_pos hΟ).le).trans_eq (mul_one _)) | |
| lemma actualChartRemainder_taylor (k : β) {Ο : β} (hΟ : 0<Ο) (z : β) | |
| (hz : RegularChartPoint k Ο (complexProjection z)) | |
| (hn : RegularChartPoint k Ο (standardMap k (complexProjection z))) (v w : RealPlane) : | |
| βactualChartRemainder k Ο z w-actualChartRemainder k Ο z v- | |
| actualChartRemainderDerivative k Ο z v (w-v)ββ€hyperbolicChartError Ο*βw-vβ^2 := | |
| quadratic_taylor_of_derivative_lipschitz _ _ (hasFDerivAt_actualChartRemainder k Ο z) | |
| (hyperbolicChartError_pos hΟ).le (actualChartRemainderDerivative_lipschitz k hΟ z hz hn) v w | |
| lemma actualChartRemainder_quadratic (k : β) {Ο : β} (hΟ : 0<Ο) (z : β) | |
| (hz : RegularChartPoint k Ο (complexProjection z)) | |
| (hn : RegularChartPoint k Ο (standardMap k (complexProjection z))) (v : RealPlane) : | |
| βactualChartRemainder k Ο z vββ€hyperbolicChartError Ο*βvβ^2 := by | |
| simpa only [actualChartRemainder_zero,actualChartRemainderDerivative_zero,zero_apply,sub_zero] using | |
| actualChartRemainder_taylor k hΟ z hz hn 0 v | |
| end StandardMapEntropy | |
| end | |
| section | |
| namespace StandardMapEntropy.NonlinearStable | |
| open Filter Set | |
| open scoped Topology NNReal | |
| variable {β Ξ΄ : ββ₯0} | |
| lemma linearized_difference_residual (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane βL[β] Plane) (hD : β n, βD nββ€Ξ΄) | |
| {s t : β} (hs : |s|β€1) (ht : |t|β€1) (n : β) : | |
| (r.extend.solution h t-r.extend.solution h s) (n+1)- | |
| (r.linearized D hD).step n ((r.extend.solution h t-r.extend.solution h s) n) = | |
| r.remainder n (r.extend.solution h t n)-r.remainder n (r.extend.solution h s n)- | |
| D n (r.extend.solution h t n-r.extend.solution h s n) := by | |
| simp only [BoundedContinuousFunction.sub_apply,local_solution_orbit r h hs,local_solution_orbit r h ht] | |
| apply Prod.ext <;> simp only [Prod.fst_sub,Prod.snd_sub,LocalRecurrence.step,LocalRecurrence.linearized,Recurrence.step] <;> ring | |
| lemma solution_quadratic_approximation (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane βL[β] Plane) (hD : β n, βD nββ€Ξ΄) | |
| {M : β} (hM : 0β€M) {s t : β} (hs : |s|β€1) (ht : |t|β€1) | |
| (hTaylor : β n, βr.remainder n (r.extend.solution h t n)-r.remainder n (r.extend.solution h s n)- | |
| D n (r.extend.solution h t n-r.extend.solution h s n)ββ€ | |
| M*βr.extend.solution h t n-r.extend.solution h s nβ^2) : | |
| βr.extend.solution h t-r.extend.solution h s-(t-s) β’ (r.linearized D hD).solution h 1ββ€ | |
| (M/(1-((β+Ξ΄ : ββ₯0) : β)))*|t-s|^2 := by | |
| have hstep (n : β) : β(r.extend.solution h t-r.extend.solution h s) (n+1)- | |
| (r.linearized D hD).step n ((r.extend.solution h t-r.extend.solution h s) n)ββ€M*|t-s|^2 := by | |
| rw [linearized_difference_residual r h D hD hs ht n] | |
| apply (hTaylor n).trans | |
| apply mul_le_mul_of_nonneg_left _ hM | |
| exact pow_le_pow_leftβ (norm_nonneg _) ((point_sub_bound _ _ n).trans (solution_lipschitz r.extend h t s)) 2 | |
| have h0 : ((r.extend.solution h t-r.extend.solution h s) 0).1=t-s := by | |
| simp only [BoundedContinuousFunction.sub_apply,Prod.fst_sub,solution_initial] | |
| have hh := near_orbit_solution_bound (r.linearized D hD) h (t-s) (r.extend.solution h t-r.extend.solution h s) | |
| (mul_nonneg hM (sq_nonneg _)) h0 hstep | |
| rw [linearized_solution_smul] at hh | |
| exact hh.trans_eq (by ring) | |
| noncomputable def graphLinearization (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) (s : β) (hs : |s|β€1) : Sequence := | |
| (r.linearized (fun n => D n (r.extend.solution h s n)) | |
| (fun n => hD n _ (local_solution_bound r h hs n))).solution h 1 | |
| lemma solution_hasDerivAt (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) | |
| {M : β} (hM : 0β€M) | |
| (hTaylor : β n v w, βvββ€1 β βwββ€1 β | |
| βr.remainder n w-r.remainder n v-D n v (w-v)ββ€M*βw-vβ^2) | |
| {s : β} (hs : |s|<1) : | |
| HasDerivAt (r.extend.solution h) (graphLinearization r h D hD s hs.le) s := by | |
| apply hasDerivAt_of_quadratic_bound (div_nonneg hM (sub_nonneg.mpr (show ((β+Ξ΄ : ββ₯0) : β)β€1 from h.le))) | |
| have hnear : Ioo (-1 : β) 1βπ s := isOpen_Ioo.mem_nhds (abs_lt.mp hs) | |
| filter_upwards [hnear] with t ht | |
| have ht' : |t|β€1 := abs_le.mpr β¨ht.1.le,ht.2.leβ© | |
| exact solution_quadratic_approximation r h _ _ hM hs.le ht' | |
| (fun n => hTaylor n _ _ (local_solution_bound r h hs.le n) (local_solution_bound r h ht' n)) | |
| noncomputable def sequenceEval (n : β) : Sequence βL[β] Plane := | |
| ({ toFun := fun x => x n | |
| map_add' := fun _ _ => rfl | |
| map_smul' := fun _ _ => rfl } : Sequence ββ[β] Plane).mkContinuous 1 | |
| (fun x => by change βx nββ€1*βxβ; simpa only [one_mul] using x.norm_coe_le_norm n) | |
| @[simp] lemma sequenceEval_apply (n : β) (x : Sequence) : sequenceEval n x=x n := rfl | |
| lemma graph_hasDerivAt (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) | |
| {M : β} (hM : 0β€M) | |
| (hTaylor : β n v w, βvββ€1 β βwββ€1 β | |
| βr.remainder n w-r.remainder n v-D n v (w-v)ββ€M*βw-vβ^2) | |
| {s : β} (hs : |s|<1) : | |
| HasDerivAt (r.extend.graph h) (graphLinearization r h D hD s hs.le 0).2 s := by | |
| have hh := ((sequenceEval 0).hasFDerivAt.comp_hasDerivAt s (solution_hasDerivAt r h D hD hM hTaylor hs)).snd | |
| exact hh | |
| lemma linearized_difference_of_fields (r : LocalRecurrence β Ξ΄) | |
| (D E : β β Plane βL[β] Plane) (hD : β n, βD nββ€Ξ΄) (hE : β n, βE nββ€Ξ΄) | |
| (n : β) (v : Plane) : | |
| (r.linearized D hD).step n v-(r.linearized E hE).step n v=(D n-E n) v := by | |
| apply Prod.ext <;> simp only [LocalRecurrence.linearized,Recurrence.step,Prod.fst_sub,Prod.snd_sub, | |
| sub_apply] <;> ring | |
| lemma linearized_solution_field_bound (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D E : β β Plane βL[β] Plane) (hD : β n, βD nββ€Ξ΄) (hE : β n, βE nββ€Ξ΄) | |
| {B : β} (hB : 0β€B) (hDE : β n, βD n-E nββ€B) : | |
| β(r.linearized D hD).solution h 1-(r.linearized E hE).solution h 1ββ€B/(1-((β+Ξ΄ : ββ₯0) : β)) := by | |
| apply near_orbit_solution_bound _ h 1 _ hB (solution_initial _ h 1) | |
| intro n | |
| rw [solution_orbit,linearized_difference_of_fields] | |
| have hn : β(r.linearized D hD).solution h 1 nββ€1 := | |
| ((r.linearized D hD).solution h 1).norm_coe_le_norm n |>.trans (by simpa using solution_norm_bound _ h 1) | |
| calc | |
| _ β€ βD n-E nβ*β(r.linearized D hD).solution h 1 nβ := ContinuousLinearMap.le_opNorm _ _ | |
| _ β€ B*1 := mul_le_mul (hDE n) hn (norm_nonneg _) hB | |
| _ = _ := mul_one _ | |
| lemma graphLinearization_lipschitz (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) | |
| {M : β} (hM : 0β€M) | |
| (hLip : β n v w, βvββ€1 β βwββ€1 β βD n v-D n wββ€M*βv-wβ) | |
| {s t : β} (hs : |s|β€1) (ht : |t|β€1) : | |
| βgraphLinearization r h D hD s hs-graphLinearization r h D hD t htββ€ | |
| (M/(1-((β+Ξ΄ : ββ₯0) : β)))*|s-t| := by | |
| have hfields (n : β) : βD n (r.extend.solution h s n)-D n (r.extend.solution h t n)ββ€M*|s-t| := | |
| (hLip n _ _ (local_solution_bound r h hs n) (local_solution_bound r h ht n)).trans | |
| (mul_le_mul_of_nonneg_left ((point_sub_bound _ _ n).trans (solution_lipschitz _ h s t)) hM) | |
| exact (linearized_solution_field_bound r h _ _ _ _ (mul_nonneg hM (abs_nonneg _)) hfields).trans_eq (by ring) | |
| end StandardMapEntropy.NonlinearStable | |
| end | |
| section | |
| namespace StandardMapEntropy.NonlinearStable | |
| open Filter Set | |
| open scoped Topology NNReal | |
| variable {β Ξ΄ : ββ₯0} | |
| lemma graph_deriv_lipschitzOn (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) | |
| {M : β} (hM : 0β€M) | |
| (hTaylor : β n v w, βvββ€1 β βwββ€1 β | |
| βr.remainder n w-r.remainder n v-D n v (w-v)ββ€M*βw-vβ^2) | |
| (hLip : β n v w, βvββ€1 β βwββ€1 β βD n v-D n wββ€M*βv-wβ) : | |
| LipschitzOnWith β¨M/(1-((β+Ξ΄ : ββ₯0) : β)), | |
| div_nonneg hM (sub_nonneg.mpr (show ((β+Ξ΄ : ββ₯0) : β)β€1 by exact_mod_cast h.le))β© | |
| (deriv (r.extend.graph h)) (Ioo (-1 : β) 1) := by | |
| refine lipschitzOnWith_iff_norm_sub_le.mpr ?_ | |
| intro s hs t ht | |
| have hs' : |s|<1 := abs_lt.mpr hs | |
| have ht' : |t|<1 := abs_lt.mpr ht | |
| rw [(graph_hasDerivAt r h D hD hM hTaylor hs').deriv, | |
| (graph_hasDerivAt r h D hD hM hTaylor ht').deriv] | |
| exact (norm_snd_le _).trans ((point_sub_bound _ _ 0).trans | |
| (graphLinearization_lipschitz r h D hD hM hLip hs'.le ht'.le)) | |
| lemma graph_contDiffOn (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| (D : β β Plane β Plane βL[β] Plane) | |
| (hD : β n v, βvββ€1 β βD n vββ€Ξ΄) | |
| {M : β} (hM : 0β€M) | |
| (hTaylor : β n v w, βvββ€1 β βwββ€1 β | |
| βr.remainder n w-r.remainder n v-D n v (w-v)ββ€M*βw-vβ^2) | |
| (hLip : β n v w, βvββ€1 β βwββ€1 β βD n v-D n wββ€M*βv-wβ) : | |
| ContDiffOn β 1 (r.extend.graph h) (Ioo (-1 : β) 1) := by | |
| rw [contDiffOn_one_iff_derivWithin isOpen_Ioo.uniqueDiffOn] | |
| refine β¨fun s hs => (graph_hasDerivAt r h D hD hM hTaylor (abs_lt.mpr hs)).differentiableAt.differentiableWithinAt, ?_β© | |
| exact (graph_deriv_lipschitzOn r h D hD hM hTaylor hLip).continuousOn.congr | |
| (fun s hs => derivWithin_of_isOpen isOpen_Ioo hs) | |
| lemma graph_hasDerivAt_zero (r : LocalRecurrence β Ξ΄) (h : β+Ξ΄<1) | |
| {B : β} (hB : 0β€B) | |
| (hr : β n (v : Plane), βvββ€1 β βr.remainder n vββ€B*βvβ^2) : | |
| HasDerivAt (r.extend.graph h) 0 0 := by | |
| apply hasDerivAt_of_quadratic_bound (div_nonneg (mul_nonneg β.coe_nonneg hB) | |
| (sub_nonneg.mpr (linearRate_lt_one h).le)) | |
| filter_upwards [isOpen_Ioo.mem_nhds (show (0 : β)βIoo (-1 : β) 1 by constructor <;> norm_num)] with s hs | |
| simpa only [graph_zero,smul_zero,sub_zero,Real.norm_eq_abs] using | |
| local_graph_quadratic_bound r h hB hr (le_of_lt (abs_lt.mpr hs)) | |
| end StandardMapEntropy.NonlinearStable | |
| end | |
| section | |
| namespace StandardMapEntropy | |
| open MeasureTheory Set Filter | |
| open scoped Topology NNReal ENNReal | |
| open NonlinearStable | |
| noncomputable def actualStableGraph (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : β β β := | |
| (actualLocalRecurrence k Ο hΟ w hw).extend.graph (chart_rates_contract hΟ) | |
| noncomputable def actualStableCurve (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : β β β := | |
| fun s => w+actualChartFrame k Ο (complexProjection w) (s,actualStableGraph k Ο hΟ w hw s) | |
| lemma actualStableGraph_contDiffOn (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : | |
| ContDiffOn β 1 (actualStableGraph k Ο hΟ w hw) (Ioo (-1 : β) 1) := by | |
| apply graph_contDiffOn (actualLocalRecurrence k Ο hΟ w hw) (chart_rates_contract hΟ) | |
| (fun n => actualChartRemainderDerivative k Ο ((standardLift k)^[n] w)) | |
| (fun n v hv => actualChartRemainderDerivative_bound k hΟ _ (hw n) (regular_lift_next k Ο w hw n) hv) | |
| (hyperbolicChartError_pos hΟ).le | |
| Β· intro n v u _ _ | |
| exact actualChartRemainder_taylor k hΟ _ (hw n) (regular_lift_next k Ο w hw n) v u | |
| Β· intro n v u _ _ | |
| exact actualChartRemainderDerivative_lipschitz k hΟ _ (hw n) (regular_lift_next k Ο w hw n) v u | |
| lemma actualStableGraph_hasDerivAt_zero (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : | |
| HasDerivAt (actualStableGraph k Ο hΟ w hw) 0 0 := by | |
| exact graph_hasDerivAt_zero (actualLocalRecurrence k Ο hΟ w hw) (chart_rates_contract hΟ) | |
| (hyperbolicChartError_pos hΟ).le | |
| (fun n v _ => actualChartRemainder_quadratic k hΟ _ (hw n) (regular_lift_next k Ο w hw n) v) | |
| lemma actualStableCurve_contDiffOn (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : | |
| ContDiffOn β 1 (actualStableCurve k Ο hΟ w hw) (Ioo (-1 : β) 1) := by | |
| exact contDiffOn_const.add ((actualChartFrame k Ο (complexProjection w)).contDiff.comp_contDiffOn | |
| (contDiffOn_id.prodMk (actualStableGraph_contDiffOn k Ο hΟ w hw))) | |
| lemma actualStableCurve_hasDerivAt_zero (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) : | |
| HasDerivAt (actualStableCurve k Ο hΟ w hw) | |
| (actualChartFrame k Ο (complexProjection w) (1,0)) 0 := | |
| HasDerivAt.const_add w ((actualChartFrame k Ο (complexProjection w)).hasFDerivAt.comp_hasDerivAt 0 | |
| ((hasDerivAt_id (0 : β)).prodMk (actualStableGraph_hasDerivAt_zero k Ο hΟ w hw))) | |
| lemma actualStableCurve_regular (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) | |
| {s : β} (hs : |s|<1) : deriv (actualStableCurve k Ο hΟ w hw) sβ 0 := by | |
| have hg := (actualStableGraph_contDiffOn k Ο hΟ w hw).differentiableOn (by norm_num) | |
| s (abs_lt.mp hs) | |
| have hg' := (hg.differentiableAt (isOpen_Ioo.mem_nhds (abs_lt.mp hs))).hasDerivAt | |
| have hd := HasDerivAt.const_add w ((actualChartFrame k Ο (complexProjection w)).hasFDerivAt.comp_hasDerivAt s | |
| ((hasDerivAt_id s).prodMk hg')) | |
| have hd' : HasDerivAt (actualStableCurve k Ο hΟ w hw) | |
| (actualChartFrame k Ο (complexProjection w) (1,deriv (actualStableGraph k Ο hΟ w hw) s)) s := hd | |
| rw [hd'.deriv] | |
| intro he | |
| have hw0 : RegularChartPoint k Ο (complexProjection w) := hw 0 | |
| have hi := congrArg (actualChartInverse k Ο (complexProjection w)) he | |
| rw [actualChartInverse_frame k hΟ _ hw0.1,map_zero] at hi | |
| have hi' := congrArg Prod.fst hi | |
| exact one_ne_zero hi' | |
| lemma actualStableFrame_tangent (k Ο : β) (w : β) : | |
| actualChartFrame k Ο (complexProjection w) (1,0)= | |
| (chartSize k Ο (complexProjection w)/(2*stableScale k Ο (complexProjection w))) β’ | |
| stableVector k (complexProjection w) := by | |
| simp only [actualChartFrame,flatFrame,ContinuousLinearMap.comp_apply,smul_apply, | |
| pairToComplex_apply,lyapunovFrame,planeFrame_apply,zero_smul,add_zero,smul_smul, | |
| div_eq_mul_inv,one_mul,zero_mul] | |
| lemma actualStableCurve_orbit (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) | |
| {s : β} (hs : |s|β€1) (n : β) : | |
| (standardLift k)^[n] (actualStableCurve k Ο hΟ w hw s)=(standardLift k)^[n] w+ | |
| actualChartFrame k Ο (complexProjection ((standardLift k)^[n] w)) | |
| ((actualLocalRecurrence k Ο hΟ w hw).extend.solution (chart_rates_contract hΟ) s n) := by | |
| have hi : (actualLocalRecurrence k Ο hΟ w hw).extend.solution (chart_rates_contract hΟ) s 0= | |
| (s,actualStableGraph k Ο hΟ w hw s) := Prod.ext (solution_initial _ _ s) rfl | |
| simpa only [hi,actualStableCurve] using actual_local_orbit_lift k Ο hΟ w hw | |
| ((actualLocalRecurrence k Ο hΟ w hw).extend.solution (chart_rates_contract hΟ) s) | |
| (local_solution_orbit _ _ hs) n | |
| lemma actualStableCurve_contraction (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w))) | |
| {s t : β} (hs : |s|β€1) (ht : |t|β€1) (n : β) : | |
| β(standardLift k)^[n] (actualStableCurve k Ο hΟ w hw s)- | |
| (standardLift k)^[n] (actualStableCurve k Ο hΟ w hw t)ββ€ | |
| (2*hyperbolicChartScale k Ο)*(hyperbolicChartRate Ο+hyperbolicChartError Ο)^n*|s-t| := by | |
| rw [actualStableCurve_orbit k Ο hΟ w hw hs,actualStableCurve_orbit k Ο hΟ w hw ht, | |
| add_sub_add_left_eq_sub,βmap_sub] | |
| have hn : βactualChartFrame k Ο (complexProjection ((standardLift k)^[n] w))ββ€2*hyperbolicChartScale k Ο := | |
| (actualChartFrame_norm_le k hΟ _).trans (mul_le_mul_of_nonneg_left (chartSize_le_scale k hΟ _) (by norm_num)) | |
| have hx := solution_exponential_contraction (actualLocalRecurrence k Ο hΟ w hw).extend (chart_rates_contract hΟ) s t n | |
| exact ((ContinuousLinearMap.le_opNorm _ _).trans (mul_le_mul hn hx (norm_nonneg _) | |
| (by linarith [hyperbolicChartScale_pos k hΟ]))).trans_eq (by | |
| change (2*hyperbolicChartScale k Ο)*((hyperbolicChartRate Ο+hyperbolicChartError Ο)^n*|s-t|)=_; ring) | |
| theorem ae_actual_stable_C1 (k : β) (hk : 0β€k) (Ο : β) (hΟ : 0<Ο) : | |
| βα΅ z βarea.restrict (spectralGapRegion k hk Ο), β w : β, complexProjection w=z β | |
| β Ξ³ : β β β, Ξ³ 0=w β§ ContDiffOn β 1 Ξ³ (Ioo (-1 : β) 1) β§ | |
| HasDerivAt Ξ³ ((chartSize k Ο z/(2*stableScale k Ο z)) β’ stableVector k z) 0 β§ | |
| (β s : β, |s|<1 β deriv Ξ³ sβ 0) β§ | |
| (β s t : β, |s|β€1 β |t|β€1 β β n : β, | |
| β(standardLift k)^[n] (Ξ³ s)-(standardLift k)^[n] (Ξ³ t)ββ€ | |
| (2*hyperbolicChartScale k Ο)*(hyperbolicChartRate Ο+hyperbolicChartError Ο)^n*|s-t|) := by | |
| filter_upwards [ae_regularChartPoint_all_iterates k hk hΟ] with z hz | |
| intro w hw | |
| have hr (n : β) : RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] w)) := by | |
| simpa only [complexProjection_iterate,hw] using (hz n).1 | |
| refine β¨actualStableCurve k Ο hΟ w hr,?_,actualStableCurve_contDiffOn k Ο hΟ w hr,?_, | |
| fun s hs => actualStableCurve_regular k Ο hΟ w hr hs,fun s t hs ht n => actualStableCurve_contraction k Ο hΟ w hr hs ht nβ© | |
| Β· simp only [actualStableCurve,actualStableGraph,graph_zero,Prod.mk_zero_zero,map_zero,add_zero] | |
| Β· have hd := actualStableCurve_hasDerivAt_zero k Ο hΟ w hr | |
| rw [actualStableFrame_tangent] at hd | |
| simpa only [hw] using hd | |
| end StandardMapEntropy | |
| end | |
| section | |
| namespace StandardMapEntropy | |
| open MeasureTheory Set Filter | |
| open scoped Topology ENNReal | |
| @[simp] lemma standardReversal_involutive (z : Torus) : standardReversal (standardReversal z)=z := by | |
| apply Prod.ext <;> simp | |
| @[simp] lemma complexProjection_tangentReversal (w : β) : | |
| complexProjection (tangentReversal w)=standardReversal (complexProjection w) := by | |
| apply Prod.ext <;> simp [complexProjection] | |
| lemma tangentReversal_inverseLift (k : β) (w : β) : | |
| tangentReversal (standardInverseLift k w)=standardLift k (tangentReversal w) := by | |
| apply Complex.ext <;> simp [standardInverseLift,standardLift] <;> ring | |
| lemma tangentReversal_inverse_lift_iterate (k : β) (n : β) (w : β) : | |
| tangentReversal ((standardInverseLift k)^[n] w)=(standardLift k)^[n] (tangentReversal w) := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => rw [Function.iterate_succ_apply',tangentReversal_inverseLift,ih,Function.iterate_succ_apply'] | |
| lemma inverse_lift_iterate_reversed (k : β) (n : β) (w : β) : | |
| (standardInverseLift k)^[n] (tangentReversal w)=tangentReversal ((standardLift k)^[n] w) := by | |
| have hh := congrArg tangentReversal (tangentReversal_inverse_lift_iterate k n (tangentReversal w)) | |
| simpa only [tangentReversal_involutive] using hh | |
| lemma tangentReversal_norm_le (w : β) : βtangentReversal wββ€3*βwβ := by | |
| have hh := Complex.norm_le_abs_re_add_abs_im (tangentReversal w) | |
| simp only [tangentReversal_re,tangentReversal_im,abs_neg] at hh | |
| have hh' := abs_sub w.re w.im | |
| have hr := Complex.abs_re_le_norm w | |
| have hi := Complex.abs_im_le_norm w | |
| linarith | |
| lemma tangentReversal_ne_zero {w : β} (hw : wβ 0) : tangentReversal wβ 0 := by | |
| intro he | |
| have hh := congrArg tangentReversal he | |
| exact hw (by simpa only [tangentReversal_involutive,map_zero] using hh) | |
| lemma measurePreserving_reversal_spectralGapRegion (k : β) (hk : 0β€k) (Ο : β) : | |
| MeasurePreserving standardReversal (area.restrict (spectralGapRegion k hk Ο)) | |
| (area.restrict (spectralGapRegion k hk Ο)) := by | |
| have hh := measurePreserving_standardReversal.restrict_preimage (measurableSet_spectralGapRegion k hk Ο) | |
| have he : standardReversal β»ΒΉ' spectralGapRegion k hk Ο =α΅[area] spectralGapRegion k hk Ο := by | |
| filter_upwards [standardLyapunov_reversal_ae k hk] with z hz | |
| change (Ο<standardLyapunov k hk (standardReversal z))=(Ο<standardLyapunov k hk z) | |
| rw [hz] | |
| rwa [Measure.restrict_congr_set he] at hh | |
| lemma ae_stableVector_reversal_unstable (k : β) (hk : 0β€k) : | |
| βα΅ z βarea, 0<standardLyapunov k hk z β | |
| wedge (unstableVector k z) (tangentReversal (stableVector k (standardReversal z)))=0 := by | |
| filter_upwards [standardLyapunov_reversal_ae k hk,ae_unstableVector_growth k hk, | |
| measurePreserving_standardReversal.quasiMeasurePreserving.ae (ae_stableVector_growth k hk)] with z he hu hs hp | |
| have hu0 := PlaneLyapunov.norm_tendsto_zero_of_negative_growth _ | |
| (standardInverseDerivativeProduct_area k z) (hu hp) (by linarith) | |
| have hs0 := PlaneLyapunov.norm_tendsto_zero_of_negative_growth _ | |
| (standardDerivativeProduct_area k (standardReversal z)) (hs (by rwa [he])) (by rw [he]; linarith) | |
| apply contracting_wedge_zero _ (standardInverseDerivativeProduct_area k z) hu0 | |
| apply squeeze_zero (fun _ => norm_nonneg _) (fun n => ?_) | |
| (by simpa only [mul_zero] using Tendsto.const_mul 3 hs0) | |
| rw [standardInverseDerivativeProduct_conjugate] | |
| simp only [ContinuousLinearMap.comp_apply,tangentReversal_involutive] | |
| exact tangentReversal_norm_le _ | |
| lemma ae_reversal_tangent_transverse (k : β) (hk : 0β€k) : | |
| βα΅ z βarea, 0<standardLyapunov k hk z β | |
| wedge (stableVector k z) (tangentReversal (stableVector k (standardReversal z)))β 0 := by | |
| filter_upwards [ae_stableVector_reversal_unstable k hk,ae_transverseLines k hk] with z hu hs hp | |
| have he := unit_collinear_eq_smul (norm_unstableVector k z) (hu hp) | |
| have hc : dot (unstableVector k z) (tangentReversal (stableVector k (standardReversal z)))β 0 := by | |
| intro hz | |
| rw [hz,zero_smul] at he | |
| exact tangentReversal_ne_zero (stableVector_ne_zero k _) he | |
| rw [he,wedge_smul_right] | |
| exact mul_ne_zero hc (hs hp) | |
| end StandardMapEntropy | |
| end | |
| section | |
| namespace StandardMapEntropy | |
| open MeasureTheory Set Filter | |
| open scoped Topology NNReal ENNReal | |
| open NonlinearStable | |
| noncomputable def actualUnstableCurve (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w)))) : β β β := | |
| fun s => tangentReversal (actualStableCurve k Ο hΟ (tangentReversal w) hw s) | |
| lemma actualUnstableCurve_contDiffOn (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w)))) : | |
| ContDiffOn β 1 (actualUnstableCurve k Ο hΟ w hw) (Ioo (-1 : β) 1) := | |
| tangentReversal.contDiff.comp_contDiffOn (actualStableCurve_contDiffOn k Ο hΟ (tangentReversal w) hw) | |
| lemma actualUnstableCurve_hasDerivAt_zero (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w)))) : | |
| HasDerivAt (actualUnstableCurve k Ο hΟ w hw) | |
| ((chartSize k Ο (standardReversal (complexProjection w))/(2*stableScale k Ο (standardReversal (complexProjection w)))) β’ | |
| tangentReversal (stableVector k (standardReversal (complexProjection w)))) 0 := by | |
| have hh := tangentReversal.hasFDerivAt.comp_hasDerivAt 0 (actualStableCurve_hasDerivAt_zero k Ο hΟ (tangentReversal w) hw) | |
| rw [actualStableFrame_tangent,complexProjection_tangentReversal,map_smul] at hh | |
| exact hh | |
| lemma actualUnstableCurve_regular (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w)))) | |
| {s : β} (hs : |s|<1) : deriv (actualUnstableCurve k Ο hΟ w hw) sβ 0 := by | |
| have hd := ((actualStableCurve_contDiffOn k Ο hΟ (tangentReversal w) hw).differentiableOn (by norm_num) | |
| s (abs_lt.mp hs)).differentiableAt (isOpen_Ioo.mem_nhds (abs_lt.mp hs)) | |
| have hh : HasDerivAt (actualUnstableCurve k Ο hΟ w hw) | |
| (tangentReversal (deriv (actualStableCurve k Ο hΟ (tangentReversal w) hw) s)) s := | |
| tangentReversal.hasFDerivAt.comp_hasDerivAt s hd.hasDerivAt | |
| rw [hh.deriv] | |
| exact tangentReversal_ne_zero (actualStableCurve_regular k Ο hΟ (tangentReversal w) hw hs) | |
| lemma actualUnstableCurve_contraction (k Ο : β) (hΟ : 0<Ο) (w : β) | |
| (hw : β n : β, RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w)))) | |
| {s t : β} (hs : |s|β€1) (ht : |t|β€1) (n : β) : | |
| β(standardInverseLift k)^[n] (actualUnstableCurve k Ο hΟ w hw s)- | |
| (standardInverseLift k)^[n] (actualUnstableCurve k Ο hΟ w hw t)ββ€ | |
| (6*hyperbolicChartScale k Ο)*(hyperbolicChartRate Ο+hyperbolicChartError Ο)^n*|s-t| := by | |
| simp only [actualUnstableCurve,inverse_lift_iterate_reversed,βmap_sub] | |
| exact ((tangentReversal_norm_le _).trans (mul_le_mul_of_nonneg_left | |
| (actualStableCurve_contraction k Ο hΟ (tangentReversal w) hw hs ht n) (by norm_num))).trans_eq (by ring) | |
| theorem ae_actual_unstable_C1 (k : β) (hk : 0β€k) (Ο : β) (hΟ : 0<Ο) : | |
| βα΅ z βarea.restrict (spectralGapRegion k hk Ο), β w : β, complexProjection w=z β | |
| β Ξ³ : β β β, Ξ³ 0=w β§ ContDiffOn β 1 Ξ³ (Ioo (-1 : β) 1) β§ | |
| HasDerivAt Ξ³ ((chartSize k Ο (standardReversal z)/(2*stableScale k Ο (standardReversal z))) β’ | |
| tangentReversal (stableVector k (standardReversal z))) 0 β§ | |
| wedge (unstableVector k z) (deriv Ξ³ 0)=0 β§ | |
| (β s : β, |s|<1 β deriv Ξ³ sβ 0) β§ | |
| (β s t : β, |s|β€1 β |t|β€1 β β n : β, | |
| β(standardInverseLift k)^[n] (Ξ³ s)-(standardInverseLift k)^[n] (Ξ³ t)ββ€ | |
| (6*hyperbolicChartScale k Ο)*(hyperbolicChartRate Ο+hyperbolicChartError Ο)^n*|s-t|) := by | |
| have hr := (measurePreserving_reversal_spectralGapRegion k hk Ο).quasiMeasurePreserving.ae | |
| (ae_regularChartPoint_all_iterates k hk hΟ) | |
| filter_upwards [hr,(ae_stableVector_reversal_unstable k hk).filter_mono ae_restrict_le, | |
| ae_restrict_mem (measurableSet_spectralGapRegion k hk Ο)] with z hz hline hgap | |
| intro w hw | |
| have hreg (n : β) : RegularChartPoint k Ο (complexProjection ((standardLift k)^[n] (tangentReversal w))) := by | |
| simpa only [complexProjection_iterate,complexProjection_tangentReversal,hw] using (hz n).1 | |
| have hd := actualUnstableCurve_hasDerivAt_zero k Ο hΟ w hreg | |
| rw [hw] at hd | |
| refine β¨actualUnstableCurve k Ο hΟ w hreg,?_,actualUnstableCurve_contDiffOn k Ο hΟ w hreg,hd,?_, | |
| fun s hs => actualUnstableCurve_regular k Ο hΟ w hreg hs, | |
| fun s t hs ht n => actualUnstableCurve_contraction k Ο hΟ w hreg hs ht nβ© | |
| Β· simp only [actualUnstableCurve,actualStableCurve,actualStableGraph,graph_zero, | |
| Prod.mk_zero_zero,map_zero,add_zero,tangentReversal_involutive] | |
| Β· rw [hd.deriv,wedge_smul_right,hline (hΟ.trans hgap),mul_zero] | |
| end StandardMapEntropy | |
| end | |
| end | |
| end OAI | |