| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Lyapunov.MeasurableFrame |
|
|
| namespace OAI |
|
|
| section |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped Topology ENNReal |
|
|
| lemma potential_lift_sub_bound (k : ℝ) (z w : ℂ) : |
| |torusPotential k (complexProjection z).1-torusPotential k (complexProjection w).1|≤ |
| 4*Real.pi^2*|k| *‖z-w‖ := by |
| have hc := Real.abs_cos_sub_cos_le (2*Real.pi*z.re) (2*Real.pi*w.re) |
| have hz : |z.re-w.re|≤‖z-w‖ := Complex.abs_re_le_norm (z-w) |
| have he : torusPotential k (complexProjection z).1-torusPotential k (complexProjection w).1 = |
| 2*Real.pi*k*(Real.cos (2*Real.pi*z.re)-Real.cos (2*Real.pi*w.re)) := by |
| simp only [complexProjection,torusPotential,cosine_coe] |
| ring |
| rw [he,abs_mul] |
| calc |
| _ ≤ |2*Real.pi*k| * |2*Real.pi*z.re-2*Real.pi*w.re| := |
| mul_le_mul_of_nonneg_left hc (abs_nonneg _) |
| _ = (4*Real.pi^2*|k|)*|z.re-w.re| := by |
| rw [show 2*Real.pi*z.re-2*Real.pi*w.re=2*Real.pi*(z.re-w.re) by ring] |
| simp only [abs_mul,abs_of_pos Real.pi_pos,abs_of_pos (by norm_num : (0 : ℝ)<2)] |
| ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left hz (by positivity) |
|
|
| noncomputable def derivativeVariationBound (k : ℝ) : ℝ := 8*Real.pi^2*|k| |
| lemma derivativeVariationBound_nonneg (k : ℝ) : 0≤derivativeVariationBound k := by |
| unfold derivativeVariationBound |
| positivity |
|
|
| lemma standardDerivative_lift_sub_bound (k : ℝ) (z w : ℂ) : |
| ‖standardDerivative k (complexProjection z)-standardDerivative k (complexProjection w)‖≤ |
| derivativeVariationBound k*‖z-w‖ := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (mul_nonneg (derivativeVariationBound_nonneg k) (norm_nonneg _)) |
| intro v |
| have hre : ((standardDerivative k (complexProjection z)-standardDerivative k (complexProjection w)) v).re = |
| (torusPotential k (complexProjection z).1-torusPotential k (complexProjection w).1)*v.re := by |
| simp only [sub_apply,Complex.sub_re,standardDerivative_re] |
| ring |
| have him : ((standardDerivative k (complexProjection z)-standardDerivative k (complexProjection w)) v).im = |
| (torusPotential k (complexProjection z).1-torusPotential k (complexProjection w).1)*v.re := by |
| simp only [sub_apply,Complex.sub_im,standardDerivative_im] |
| ring |
| calc |
| _ ≤ |((standardDerivative k (complexProjection z)-standardDerivative k (complexProjection w)) v).re|+ |
| |((standardDerivative k (complexProjection z)-standardDerivative k (complexProjection w)) v).im| := |
| Complex.norm_le_abs_re_add_abs_im _ |
| _ = 2*|torusPotential k (complexProjection z).1-torusPotential k (complexProjection w).1| * |v.re| := by |
| rw [hre,him,abs_mul] |
| ring |
| _ ≤ 2*(4*Real.pi^2*|k| *‖z-w‖)*‖v‖ := |
| mul_le_mul (mul_le_mul_of_nonneg_left (potential_lift_sub_bound k z w) (by norm_num)) |
| (Complex.abs_re_le_norm v) (abs_nonneg _) (by positivity) |
| _ = _ := by unfold derivativeVariationBound; ring |
|
|
| noncomputable def liftRemainder (k : ℝ) (z v : ℂ) : ℂ := |
| standardLift k (z+v)-standardLift k z-standardDerivative k (complexProjection z) v |
| @[simp] lemma liftRemainder_zero (k : ℝ) (z : ℂ) : liftRemainder k z 0=0 := by |
| simp only [liftRemainder,add_zero,sub_self,map_zero] |
|
|
| lemma hasFDerivAt_liftRemainder (k : ℝ) (z v : ℂ) : |
| HasFDerivAt (liftRemainder k z) |
| (standardDerivative k (complexProjection (z+v))-standardDerivative k (complexProjection z)) v := by |
| have hh := ((hasFDerivAt_standardLift k (z+v)).comp v ((hasFDerivAt_id v).const_add z)).sub_const (standardLift k z) |
| have hh' := hh.sub (standardDerivative k (complexProjection z)).hasFDerivAt |
| convert! hh' using 1 |
|
|
| lemma liftRemainder_sub_bound (k : ℝ) (z : ℂ) {r : ℝ} {v w : ℂ} |
| (hv : ‖v‖≤r) (hw : ‖w‖≤r) : |
| ‖liftRemainder k z v-liftRemainder k z w‖≤derivativeVariationBound k*r*‖v-w‖ := by |
| apply (convex_closedBall (0 : ℂ) r).norm_image_sub_le_of_norm_hasFDerivWithin_le |
| (fun x _ => (hasFDerivAt_liftRemainder k z x).hasFDerivWithinAt) (fun x hx => ?_) |
| (by simpa only [Metric.mem_closedBall, dist_zero_right] using hw) |
| (by simpa only [Metric.mem_closedBall, dist_zero_right] using hv) |
| have hh := standardDerivative_lift_sub_bound k (z+x) z |
| rw [add_sub_cancel_left] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (by simpa only [Metric.mem_closedBall,dist_zero_right] using hx) |
| (derivativeVariationBound_nonneg k)) |
|
|
| noncomputable def chartRemainder (k : ℝ) (z : ℂ) (F C : ℂ →L[ℝ] ℂ) (v : ℂ) : ℂ := |
| C (liftRemainder k z (F v)) |
| @[simp] lemma chartRemainder_zero (k : ℝ) (z : ℂ) (F C : ℂ →L[ℝ] ℂ) : chartRemainder k z F C 0=0 := by |
| simp only [chartRemainder,map_zero,liftRemainder_zero] |
|
|
| lemma chartRemainder_sub_bound (k : ℝ) (z : ℂ) (F C : ℂ →L[ℝ] ℂ) {r : ℝ} |
| (hr : 0≤r) {v w : ℂ} (hv : ‖v‖≤r) (hw : ‖w‖≤r) : |
| ‖chartRemainder k z F C v-chartRemainder k z F C w‖≤ |
| (‖C‖*derivativeVariationBound k*‖F‖^2*r)*‖v-w‖ := by |
| have hfv := (F.le_opNorm v).trans (mul_le_mul_of_nonneg_left hv (norm_nonneg F)) |
| have hfw := (F.le_opNorm w).trans (mul_le_mul_of_nonneg_left hw (norm_nonneg F)) |
| have hr0 := derivativeVariationBound_nonneg k |
| calc |
| _ = ‖C (liftRemainder k z (F v)-liftRemainder k z (F w))‖ := by rw [map_sub]; rfl |
| _ ≤ ‖C‖*‖liftRemainder k z (F v)-liftRemainder k z (F w)‖ := C.le_opNorm _ |
| _ ≤ ‖C‖*(derivativeVariationBound k*(‖F‖*r)*‖F v-F w‖) := |
| mul_le_mul_of_nonneg_left (liftRemainder_sub_bound k z hfv hfw) (norm_nonneg C) |
| _ ≤ ‖C‖*(derivativeVariationBound k*(‖F‖*r)*(‖F‖*‖v-w‖)) := by |
| rw [← map_sub] |
| exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left (F.le_opNorm (v-w)) (by positivity)) (norm_nonneg C) |
| _ = _ := by ring |
|
|
| end StandardMapEntropy |
|
|
| end |
| section |
| namespace StandardMapEntropy.NonlinearStable |
| open Filter |
| open scoped Topology NNReal |
|
|
| abbrev Plane := ℝ × ℝ |
| abbrev Sequence := BoundedContinuousFunction ℕ Plane |
|
|
| structure Recurrence (ℓ δ : ℝ≥0) where |
| a : ℕ → ℝ |
| b : ℕ → ℝ |
| remainder : ℕ → Plane → Plane |
| stable_bound : ∀ n, |a n|≤ℓ |
| inverse_bound : ∀ n, |(b n)⁻¹|≤ℓ |
| b_ne : ∀ n, b n≠0 |
| lipschitz : ∀ n, LipschitzWith δ (remainder n) |
| zero : ∀ n, remainder n 0=0 |
|
|
| variable {ℓ δ : ℝ≥0} |
|
|
| def Recurrence.step (r : Recurrence ℓ δ) (n : ℕ) (v : Plane) : Plane := |
| (r.a n*v.1+(r.remainder n v).1, r.b n*v.2+(r.remainder n v).2) |
|
|
| noncomputable def Recurrence.perronValue (r : Recurrence ℓ δ) (s : ℝ) (x : Sequence) (n : ℕ) : Plane := |
| ((match n with | 0 => s | m+1 => r.a m*(x m).1+(r.remainder m (x m)).1), |
| (r.b n)⁻¹*((x (n+1)).2-(r.remainder n (x n)).2)) |
|
|
| lemma point_sub_bound (x y : Sequence) (n : ℕ) : ‖x n-y n‖≤‖x-y‖ := |
| (x-y).norm_coe_le_norm n |
| lemma fst_sub_bound (x y : Sequence) (n : ℕ) : |(x n).1-(y n).1|≤‖x-y‖ := |
| (norm_fst_le (x n-y n)).trans (point_sub_bound x y n) |
| lemma snd_sub_bound (x y : Sequence) (n : ℕ) : |(x n).2-(y n).2|≤‖x-y‖ := |
| (norm_snd_le (x n-y n)).trans (point_sub_bound x y n) |
|
|
| lemma remainder_sub_bound (r : Recurrence ℓ δ) (x y : Sequence) (n : ℕ) : |
| ‖r.remainder n (x n)-r.remainder n (y n)‖≤(δ : ℝ)*‖x-y‖ := by |
| have hh := (r.lipschitz n).dist_le_mul (x n) (y n) |
| rw [dist_eq_norm,dist_eq_norm] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (point_sub_bound x y n) δ.coe_nonneg) |
|
|
| lemma perronValue_sub_bound (r : Recurrence ℓ δ) (hℓ : ℓ≤1) |
| (s t : ℝ) (x y : Sequence) (n : ℕ) : |
| ‖r.perronValue s x n-r.perronValue t y n‖≤ |
| max |s-t| (((ℓ+δ : ℝ≥0) : ℝ)*‖x-y‖) := by |
| have hδ : 0≤(δ : ℝ) := δ.coe_nonneg |
| have hℓ0 : 0≤(ℓ : ℝ) := ℓ.coe_nonneg |
| have hℓ1 : (ℓ : ℝ)≤1 := hℓ |
| have hfst (m : ℕ) := (norm_fst_le (r.remainder m (x m)-r.remainder m (y m))).trans |
| (remainder_sub_bound r x y m) |
| have hsnd (m : ℕ) := (norm_snd_le (r.remainder m (x m)-r.remainder m (y m))).trans |
| (remainder_sub_bound r x y m) |
| rw [Prod.norm_def] |
| apply max_le |
| · cases n with |
| | zero => exact le_max_left _ _ |
| | succ m => |
| change |r.a m*(x m).1+(r.remainder m (x m)).1- |
| (r.a m*(y m).1+(r.remainder m (y m)).1)|≤_ |
| calc |
| _ = |r.a m*((x m).1-(y m).1)+((r.remainder m (x m)).1-(r.remainder m (y m)).1)| := by congr 1; ring |
| _ ≤ |r.a m| *|(x m).1-(y m).1| +|(r.remainder m (x m)).1-(r.remainder m (y m)).1| := by |
| simpa only [abs_mul] using abs_add_le (r.a m*((x m).1-(y m).1)) |
| ((r.remainder m (x m)).1-(r.remainder m (y m)).1) |
| _ ≤ (ℓ : ℝ)*‖x-y‖+(δ : ℝ)*‖x-y‖ := add_le_add |
| (mul_le_mul (r.stable_bound m) (fst_sub_bound x y m) (abs_nonneg _) hℓ0) (hfst m) |
| _ = ((ℓ+δ : ℝ≥0) : ℝ)*‖x-y‖ := by push_cast; ring |
| _ ≤ _ := le_max_right _ _ |
| · change |(r.b n)⁻¹*((x (n+1)).2-(r.remainder n (x n)).2)- |
| (r.b n)⁻¹*((y (n+1)).2-(r.remainder n (y n)).2)|≤_ |
| calc |
| _ = |(r.b n)⁻¹| *|((x (n+1)).2-(y (n+1)).2)- |
| ((r.remainder n (x n)).2-(r.remainder n (y n)).2)| := by rw [← abs_mul]; congr 1; ring |
| _ ≤ |(r.b n)⁻¹| *(|(x (n+1)).2-(y (n+1)).2| + |
| |(r.remainder n (x n)).2-(r.remainder n (y n)).2|) := |
| mul_le_mul_of_nonneg_left (abs_sub _ _) (abs_nonneg _) |
| _ ≤ (ℓ : ℝ)*(‖x-y‖+(δ : ℝ)*‖x-y‖) := mul_le_mul (r.inverse_bound n) |
| (add_le_add (snd_sub_bound x y (n+1)) (hsnd n)) (by positivity) hℓ0 |
| _ ≤ ((ℓ+δ : ℝ≥0) : ℝ)*‖x-y‖ := by |
| have hh := mul_le_mul_of_nonneg_right hℓ1 (mul_nonneg hδ (norm_nonneg (x-y))) |
| push_cast |
| nlinarith |
| _ ≤ _ := le_max_right _ _ |
|
|
| @[simp] lemma perronValue_zero (r : Recurrence ℓ δ) (n : ℕ) : r.perronValue 0 0 n=0 := by |
| cases n <;> simp [Recurrence.perronValue,r.zero] |
|
|
| lemma perronValue_norm_bound (r : Recurrence ℓ δ) (hℓ : ℓ≤1) (s : ℝ) (x : Sequence) (n : ℕ) : |
| ‖r.perronValue s x n‖≤ max |s| (((ℓ+δ : ℝ≥0) : ℝ)*‖x‖) := by |
| simpa only [perronValue_zero,sub_zero] using perronValue_sub_bound r hℓ s 0 x 0 n |
|
|
| noncomputable def Recurrence.perron (r : Recurrence ℓ δ) (hℓ : ℓ≤1) (s : ℝ) (x : Sequence) : Sequence := |
| BoundedContinuousFunction.ofNormedAddCommGroupDiscrete (r.perronValue s x) |
| (max |s| (((ℓ+δ : ℝ≥0) : ℝ)*‖x‖)) (perronValue_norm_bound r hℓ s x) |
|
|
| @[simp] lemma perron_apply (r : Recurrence ℓ δ) (hℓ : ℓ≤1) (s : ℝ) (x : Sequence) (n : ℕ) : |
| r.perron hℓ s x n=r.perronValue s x n := rfl |
|
|
| lemma perron_contracting (r : Recurrence ℓ δ) (h : ℓ+δ<1) {s : ℝ} : |
| ContractingWith (ℓ+δ) (r.perron (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) s) := by |
| refine ⟨h,LipschitzWith.of_dist_le_mul fun x y => ?_⟩ |
| rw [dist_eq_norm,dist_eq_norm] |
| apply (BoundedContinuousFunction.norm_le (by positivity)).mpr |
| intro n |
| have hh := perronValue_sub_bound r (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) s s x y n |
| simpa only [BoundedContinuousFunction.sub_apply, perron_apply, sub_self, abs_zero, |
| max_eq_right (mul_nonneg (ℓ+δ).coe_nonneg (norm_nonneg _))] using hh |
|
|
| noncomputable def Recurrence.solution (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) : Sequence := |
| ContractingWith.fixedPoint _ (perron_contracting r h (s := s)) |
|
|
| lemma solution_fixed (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) : |
| r.perron (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) s (r.solution h s)=r.solution h s := |
| (perron_contracting r h (s := s)).fixedPoint_isFixedPt |
|
|
| lemma bound_of_max_contraction {d c K : ℝ} (hc : 0≤ c) (hK : K<1) |
| (h : d≤ max c (K*d)) : d≤ c := by |
| by_contra hh |
| have hd : 0< d := hc.trans_lt (lt_of_not_ge hh) |
| have hlt : max c (K*d)< d := max_lt (lt_of_not_ge hh) (by nlinarith) |
| exact (not_lt_of_ge h) hlt |
|
|
| lemma fixed_norm_bound (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (x : Sequence) |
| (hx : r.perron (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) s x=x) : ‖x‖≤|s| := by |
| apply bound_of_max_contraction (abs_nonneg _) (show ((ℓ+δ : ℝ≥0) : ℝ)<1 from h) |
| conv_lhs => rw [← hx] |
| apply (BoundedContinuousFunction.norm_le (le_trans (abs_nonneg _) (le_max_left _ _))).mpr |
| intro n |
| exact perronValue_norm_bound r (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) s x n |
|
|
| lemma solution_norm_bound (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) : ‖r.solution h s‖≤|s| := |
| fixed_norm_bound r h s _ (solution_fixed r h s) |
|
|
| lemma solution_initial (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) : (r.solution h s 0).1=s := by |
| have hh := congrArg (fun x : Sequence => (x 0).1) (solution_fixed r h s) |
| exact hh.symm |
|
|
| lemma solution_orbit (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (n : ℕ) : |
| r.solution h s (n+1)=r.step n (r.solution h s n) := by |
| have hh := congrArg (fun x : Sequence => x (n+1)) (solution_fixed r h s) |
| have hh' := congrArg (fun x : Sequence => x n) (solution_fixed r h s) |
| apply Prod.ext |
| · exact (congrArg Prod.fst hh).symm |
| · have he := congrArg Prod.snd hh' |
| change (r.b n)⁻¹*((r.solution h s (n+1)).2-(r.remainder n (r.solution h s n)).2)= |
| (r.solution h s n).2 at he |
| change _=r.b n*(r.solution h s n).2+(r.remainder n (r.solution h s n)).2 |
| have he' := congrArg (fun t : ℝ => r.b n*t) he |
| rw [← mul_assoc, mul_inv_cancel₀ (r.b_ne n), one_mul] at he' |
| linarith |
|
|
| lemma solution_lipschitz (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ) : |
| ‖r.solution h s-r.solution h t‖≤|s-t| := by |
| apply bound_of_max_contraction (abs_nonneg _) (show ((ℓ+δ : ℝ≥0) : ℝ)<1 from h) |
| apply (BoundedContinuousFunction.norm_le (le_trans (abs_nonneg _) (le_max_left _ _))).mpr |
| intro n |
| have hh := perronValue_sub_bound r (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0) ≤ δ from bot_le)) h.le) |
| s t (r.solution h s) (r.solution h t) n |
| have h1 := congrArg (fun x : Sequence => x n) (solution_fixed r h s) |
| have h2 := congrArg (fun x : Sequence => x n) (solution_fixed r h t) |
| change r.perronValue s (r.solution h s) n=r.solution h s n at h1 |
| change r.perronValue t (r.solution h t) n=r.solution h t n at h2 |
| rwa [h1,h2] at hh |
|
|
| end StandardMapEntropy.NonlinearStable |
|
|
| end |
| section |
| namespace StandardMapEntropy.NonlinearStable |
| open Filter |
| open scoped Topology NNReal |
| variable {ℓ δ : ℝ≥0} |
|
|
| noncomputable def Sequence.tail (x : Sequence) (m : ℕ) : Sequence := |
| BoundedContinuousFunction.ofNormedAddCommGroupDiscrete (fun n => x (m+n)) ‖x‖ |
| (fun n => x.norm_coe_le_norm (m+n)) |
| @[simp] lemma tail_apply (x : Sequence) (m n : ℕ) : x.tail m n=x (m+n) := rfl |
|
|
| noncomputable def Recurrence.tail (r : Recurrence ℓ δ) (m : ℕ) : Recurrence ℓ δ where |
| a n := r.a (m+n) |
| b n := r.b (m+n) |
| remainder n := r.remainder (m+n) |
| stable_bound n := r.stable_bound (m+n) |
| inverse_bound n := r.inverse_bound (m+n) |
| b_ne n := r.b_ne (m+n) |
| lipschitz n := r.lipschitz (m+n) |
| zero n := r.zero (m+n) |
|
|
| lemma orbit_fixed (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (x : Sequence) |
| (h0 : (x 0).1=s) (horbit : ∀ n, x (n+1)=r.step n (x n)) : |
| r.perron (le_trans (le_add_of_nonneg_right (show (0 : ℝ≥0)≤δ from bot_le)) h.le) s x=x := by |
| apply BoundedContinuousFunction.ext |
| intro n |
| apply Prod.ext |
| · cases n with |
| | zero => exact h0.symm |
| | succ n => exact (congrArg Prod.fst (horbit n)).symm |
| · have hh := congrArg Prod.snd (horbit n) |
| change (x (n+1)).2=r.b n*(x n).2+(r.remainder n (x n)).2 at hh |
| change (r.b n)⁻¹*((x (n+1)).2-(r.remainder n (x n)).2)=(x n).2 |
| rw [hh,add_sub_cancel_right,←mul_assoc,inv_mul_cancel₀ (r.b_ne n),one_mul] |
|
|
| lemma solution_unique (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (x : Sequence) |
| (h0 : (x 0).1=s) (horbit : ∀ n, x (n+1)=r.step n (x n)) : |
| x=r.solution h s := |
| (perron_contracting r h (s := s)).fixedPoint_unique (orbit_fixed r h s x h0 horbit) |
|
|
| lemma solution_tail (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (m : ℕ) : |
| (r.solution h s).tail m=(r.tail m).solution h (r.solution h s m).1 := by |
| apply solution_unique |
| · simp only [tail_apply,Nat.add_zero] |
| · intro n |
| simpa only [tail_apply,Recurrence.tail,Recurrence.step,Nat.add_assoc] using |
| solution_orbit r h s (m+n) |
|
|
| lemma solution_cone (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ) (n : ℕ) : |
| ‖r.solution h s n-r.solution h t n‖≤|(r.solution h s n).1-(r.solution h t n).1| := by |
| have hh := solution_lipschitz (r.tail n) h (r.solution h s n).1 (r.solution h t n).1 |
| rw [←solution_tail,←solution_tail] at hh |
| have hb := (point_sub_bound ((r.solution h s).tail n) ((r.solution h t).tail n) 0).trans hh |
| simpa only [tail_apply,Nat.add_zero] using hb |
|
|
| lemma step_fst_sub_bound (r : Recurrence ℓ δ) (n : ℕ) (v w : Plane) : |
| |(r.step n v).1-(r.step n w).1|≤((ℓ+δ : ℝ≥0) : ℝ)*‖v-w‖ := by |
| have hr := (r.lipschitz n).dist_le_mul v w |
| rw [dist_eq_norm,dist_eq_norm] at hr |
| have hrf := (norm_fst_le (r.remainder n v-r.remainder n w)).trans hr |
| have hvw : |v.1-w.1|≤‖v-w‖ := norm_fst_le (v-w) |
| change |r.a n*v.1+(r.remainder n v).1-(r.a n*w.1+(r.remainder n w).1)|≤_ |
| calc |
| _ = |r.a n*(v.1-w.1)+((r.remainder n v).1-(r.remainder n w).1)| := by congr 1; ring |
| _ ≤ |r.a n| * |v.1-w.1|+|(r.remainder n v).1-(r.remainder n w).1| := by |
| simpa only [abs_mul] using abs_add_le (r.a n*(v.1-w.1)) ((r.remainder n v).1-(r.remainder n w).1) |
| _ ≤ (ℓ : ℝ)*‖v-w‖+(δ : ℝ)*‖v-w‖ := add_le_add |
| (mul_le_mul (r.stable_bound n) hvw (abs_nonneg _) ℓ.coe_nonneg) hrf |
| _ = _ := by push_cast; ring |
|
|
| lemma solution_step_contraction (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ) (n : ℕ) : |
| ‖r.solution h s (n+1)-r.solution h t (n+1)‖≤ |
| ((ℓ+δ : ℝ≥0) : ℝ)*‖r.solution h s n-r.solution h t n‖ := by |
| apply (solution_cone r h s t (n+1)).trans |
| rw [solution_orbit,solution_orbit] |
| exact step_fst_sub_bound r n _ _ |
|
|
| lemma solution_exponential_contraction (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ) (n : ℕ) : |
| ‖r.solution h s n-r.solution h t n‖≤((ℓ+δ : ℝ≥0) : ℝ)^n*|s-t| := by |
| induction n with |
| | zero => simpa only [pow_zero,one_mul,solution_initial] using solution_cone r h s t 0 |
| | succ n ih => |
| apply (solution_step_contraction r h s t n).trans |
| calc |
| _ ≤ ((ℓ+δ : ℝ≥0) : ℝ)*(((ℓ+δ : ℝ≥0) : ℝ)^n*|s-t|) := |
| mul_le_mul_of_nonneg_left ih (ℓ+δ).coe_nonneg |
| _ = _ := by rw [pow_succ]; ring |
|
|
| noncomputable def Recurrence.graph (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) : ℝ := |
| (r.solution h s 0).2 |
|
|
| lemma graph_lipschitz (r : Recurrence ℓ δ) (h : ℓ+δ<1) : LipschitzWith 1 (r.graph h) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [dist_eq_norm,dist_eq_norm,NNReal.coe_one,one_mul] |
| exact (norm_snd_le (r.solution h s 0-r.solution h t 0)).trans |
| ((point_sub_bound _ _ 0).trans (solution_lipschitz r h s t)) |
|
|
| lemma solution_zero (r : Recurrence ℓ δ) (h : ℓ+δ<1) : r.solution h 0=0 := by |
| exact norm_eq_zero.mp (le_antisymm (by simpa only [abs_zero] using solution_norm_bound r h 0) (norm_nonneg _)) |
|
|
| @[simp] lemma graph_zero (r : Recurrence ℓ δ) (h : ℓ+δ<1) : r.graph h 0=0 := by |
| simp [Recurrence.graph,solution_zero] |
|
|
| theorem stable_graph (r : Recurrence ℓ δ) (h : ℓ+δ<1) : |
| ∃ g : ℝ → ℝ, g 0=0 ∧ LipschitzWith 1 g ∧ |
| ∀ s : ℝ, ∃ x : Sequence, x 0=(s,g s) ∧ |
| (∀ n, x (n+1)=r.step n (x n)) ∧ |
| (∀ n, ‖x n‖≤((ℓ+δ : ℝ≥0) : ℝ)^n*|s|) ∧ |
| (∀ y : Sequence, (y 0).1=s → (∀ n, y (n+1)=r.step n (y n)) → y=x) := by |
| refine ⟨r.graph h,graph_zero r h,graph_lipschitz r h,fun s => |
| ⟨r.solution h s,?_,solution_orbit r h s,?_,fun y h0 hy => solution_unique r h s y h0 hy⟩⟩ |
| · exact Prod.ext (solution_initial r h s) rfl |
| · intro n |
| simpa [solution_zero] using |
| solution_exponential_contraction r h s 0 n |
|
|
| end StandardMapEntropy.NonlinearStable |
|
|
| end |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped Topology NNReal |
|
|
| abbrev RealPlane := ℝ × ℝ |
| noncomputable def complexToPair : ℂ →L[ℝ] RealPlane := Complex.equivRealProdCLM.toContinuousLinearMap |
| noncomputable def pairToComplex : RealPlane →L[ℝ] ℂ := Complex.equivRealProdCLM.symm.toContinuousLinearMap |
| @[simp] lemma complexToPair_apply (v : ℂ) : complexToPair v=(v.re,v.im) := rfl |
| @[simp] lemma pairToComplex_apply (v : RealPlane) : pairToComplex v=⟨v.1,v.2⟩ := rfl |
| @[simp] lemma complexToPair_pairToComplex (v : RealPlane) : complexToPair (pairToComplex v)=v := by rfl |
| @[simp] lemma pairToComplex_complexToPair (v : ℂ) : pairToComplex (complexToPair v)=v := by rfl |
| lemma complexToPair_norm_le (v : ℂ) : ‖complexToPair v‖≤‖v‖ := by |
| exact max_le (Complex.abs_re_le_norm v) (Complex.abs_im_le_norm v) |
| lemma pairToComplex_norm_le (v : RealPlane) : ‖pairToComplex v‖≤2*‖v‖ := by |
| have hh := Complex.norm_le_abs_re_add_abs_im (pairToComplex v) |
| have h1 : |v.1|≤‖v‖ := norm_fst_le v |
| have h2 : |v.2|≤‖v‖ := norm_snd_le v |
| exact hh.trans (by change |v.1|+|v.2|≤_; linarith) |
| lemma norm_complexToPair_le : ‖complexToPair‖≤1 := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (by norm_num) |
| intro v |
| simpa only [one_mul] using complexToPair_norm_le v |
| lemma norm_pairToComplex_le : ‖pairToComplex‖≤2 := |
| ContinuousLinearMap.opNorm_le_bound _ (by norm_num) pairToComplex_norm_le |
|
|
| noncomputable def flatFrame (q : ℝ) (F : ℂ →L[ℝ] ℂ) : RealPlane →L[ℝ] ℂ := |
| (q • F).comp pairToComplex |
| noncomputable def flatInverse (q : ℝ) (C : ℂ →L[ℝ] ℂ) : ℂ →L[ℝ] RealPlane := |
| complexToPair.comp (q⁻¹ • C) |
|
|
| lemma flatInverse_frame {q : ℝ} (hq : q≠0) {F C : ℂ →L[ℝ] ℂ} |
| (hCF : C.comp F=ContinuousLinearMap.id ℝ ℂ) (v : RealPlane) : |
| flatInverse q C (flatFrame q F v)=v := by |
| have hh : C (F (pairToComplex v))=pairToComplex v := congrArg (fun D : ℂ →L[ℝ] ℂ => D (pairToComplex v)) hCF |
| simp only [flatInverse,flatFrame,ContinuousLinearMap.comp_apply,smul_apply,map_smul, |
| hh,smul_smul,mul_inv_cancel₀ hq,one_smul,complexToPair_pairToComplex] |
| lemma flatFrame_inverse {q : ℝ} (hq : q≠0) {F C : ℂ →L[ℝ] ℂ} |
| (hFC : F.comp C=ContinuousLinearMap.id ℝ ℂ) (v : ℂ) : |
| flatFrame q F (flatInverse q C v)=v := by |
| have hh : F (C v)=v := congrArg (fun D : ℂ →L[ℝ] ℂ => D v) hFC |
| simp only [flatInverse,flatFrame,ContinuousLinearMap.comp_apply,smul_apply,map_smul, |
| pairToComplex_complexToPair,hh,smul_smul,inv_mul_cancel₀ hq,one_smul] |
|
|
| lemma flatFrame_norm_le {q : ℝ} (hq : 0≤q) {F : ℂ →L[ℝ] ℂ} (hF : ‖F‖≤1) : |
| ‖flatFrame q F‖≤2*q := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) |
| intro v |
| simp only [flatFrame,ContinuousLinearMap.comp_apply,smul_apply,norm_smul, |
| Real.norm_eq_abs,abs_of_nonneg hq] |
| have hh := (F.le_opNorm (pairToComplex v)).trans (mul_le_mul_of_nonneg_right hF (norm_nonneg _)) |
| have hh' : ‖F (pairToComplex v)‖≤2*‖v‖ := by simpa only [one_mul] using hh.trans (by simpa using pairToComplex_norm_le v) |
| exact (mul_le_mul_of_nonneg_left hh' hq).trans_eq (by ring) |
|
|
| lemma flatInverse_norm_le {q : ℝ} (hq : 0≤q) (C : ℂ →L[ℝ] ℂ) : |
| ‖flatInverse q C‖≤q⁻¹*‖C‖ := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) |
| intro v |
| have hh := complexToPair_norm_le (q⁻¹ • C v) |
| simp only [norm_smul,Real.norm_eq_abs,abs_inv,abs_of_nonneg hq] at hh |
| exact hh.trans ((mul_le_mul_of_nonneg_left (C.le_opNorm v) (inv_nonneg.mpr hq)).trans_eq (by ring)) |
|
|
| lemma flat_diagonal {q p : ℝ} (D F C : ℂ →L[ℝ] ℂ) {a b : ℝ} |
| (h : C.comp (D.comp F)=diagonalPlane a b) (v : RealPlane) : |
| flatInverse p C (D (flatFrame q F v))=(q/p*a*v.1,q/p*b*v.2) := by |
| have hh : C (D (F (pairToComplex v)))=diagonalPlane a b (pairToComplex v) := |
| congrArg (fun T : ℂ →L[ℝ] ℂ => T (pairToComplex v)) h |
| simp only [flatInverse,flatFrame,ContinuousLinearMap.comp_apply,smul_apply,map_smul] |
| rw [hh] |
| simp only [diagonalPlane_apply,complexToPair_apply,pairToComplex_apply] |
| apply Prod.ext <;> simp only [Prod.smul_fst,Prod.smul_snd,smul_eq_mul,div_eq_mul_inv] <;> ring |
|
|
| noncomputable def flatRemainder (k : ℝ) (z : ℂ) (F : RealPlane →L[ℝ] ℂ) |
| (C : ℂ →L[ℝ] RealPlane) (v : RealPlane) : RealPlane := C (liftRemainder k z (F v)) |
| @[simp] lemma flatRemainder_zero (k : ℝ) (z : ℂ) (F : RealPlane →L[ℝ] ℂ) |
| (C : ℂ →L[ℝ] RealPlane) : flatRemainder k z F C 0=0 := by |
| simp only [flatRemainder,map_zero,liftRemainder_zero] |
|
|
| lemma flatRemainder_sub_bound (k : ℝ) (z : ℂ) (F : RealPlane →L[ℝ] ℂ) |
| (C : ℂ →L[ℝ] RealPlane) {v w : RealPlane} (hv : ‖v‖≤1) (hw : ‖w‖≤1) : |
| ‖flatRemainder k z F C v-flatRemainder k z F C w‖≤ |
| (‖C‖*derivativeVariationBound k*‖F‖^2)*‖v-w‖ := by |
| have hfv : ‖F v‖≤‖F‖ := (F.le_opNorm v).trans (by simpa only [mul_one] using mul_le_mul_of_nonneg_left hv (norm_nonneg F)) |
| have hfw : ‖F w‖≤‖F‖ := (F.le_opNorm w).trans (by simpa only [mul_one] using mul_le_mul_of_nonneg_left hw (norm_nonneg F)) |
| calc |
| _ = ‖C (liftRemainder k z (F v)-liftRemainder k z (F w))‖ := by rw [map_sub]; rfl |
| _ ≤ ‖C‖*‖liftRemainder k z (F v)-liftRemainder k z (F w)‖ := C.le_opNorm _ |
| _ ≤ ‖C‖*(derivativeVariationBound k*‖F‖*‖F v-F w‖) := |
| mul_le_mul_of_nonneg_left (liftRemainder_sub_bound k z hfv hfw) (norm_nonneg C) |
| _ ≤ ‖C‖*(derivativeVariationBound k*‖F‖*(‖F‖*‖v-w‖)) := by |
| rw [←map_sub] |
| exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left (F.le_opNorm (v-w)) |
| (mul_nonneg (derivativeVariationBound_nonneg k) (norm_nonneg F))) (norm_nonneg C) |
| _ = _ := by ring |
|
|
| end StandardMapEntropy |
|
|
| end |
| end |
|
|
| end OAI |
|
|
