lean/OAI/Dynamics/StandardMap/Stable/LocalStable.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Stable.SmoothRemainder

namespace OAI

section
section
namespace StandardMapEntropy.NonlinearStable
open Filter
open scoped Topology NNReal

noncomputable def unitClip (x : ℝ) : ℝ := max (min x 1) (-1)
lemma abs_unitClip_le (x : ℝ) : |unitClip x|≤1 := by
  rw [abs_le]
  exact ⟨le_max_right _ _,max_le (min_le_right _ _) (by norm_num)⟩
lemma unitClip_eq {x : ℝ} (hx : |x|≤1) : unitClip x=x := by
  rw [abs_le] at hx
  simp only [unitClip,min_eq_left hx.2,max_eq_left hx.1]
lemma unitClip_lipschitz : LipschitzWith 1 unitClip :=
  (LipschitzWith.id.min_const 1).max_const (-1)

noncomputable def planeClip (v : Plane) : Plane := (unitClip v.1,unitClip v.2)
lemma norm_planeClip_le (v : Plane) : ‖planeClip v‖≤1 :=
  max_le (abs_unitClip_le _) (abs_unitClip_le _)
lemma planeClip_eq {v : Plane} (hv : ‖v‖≤1) : planeClip v=v := by
  exact Prod.ext (unitClip_eq ((norm_fst_le v).trans hv)) (unitClip_eq ((norm_snd_le v).trans hv))
@[simp] lemma planeClip_zero : planeClip 0=0 := planeClip_eq (by simp)
lemma planeClip_lipschitz : LipschitzWith 1 planeClip := by
  apply LipschitzWith.of_dist_le_mul
  intro v w
  simp only [NNReal.coe_one,one_mul,Prod.dist_eq,planeClip]
  have h1 := unitClip_lipschitz.dist_le_mul v.1 w.1
  have h2 := unitClip_lipschitz.dist_le_mul v.2 w.2
  simp only [NNReal.coe_one,one_mul] at h1 h2
  exact max_le_max h1 h2

structure LocalRecurrence (ℓ δ : ℝ≥0) where
  a : ℕ → ℝ
  b : ℕ → ℝ
  remainder : ℕ → Plane → Plane
  stable_bound : ∀ n, |a n|≤ℓ
  inverse_bound : ∀ n, |(b n)⁻¹|≤ℓ
  b_ne : ∀ n, b n≠0
  local_lipschitz : ∀ n v w, ‖v‖≤1 → ‖w‖≤1 →
    ‖remainder n v-remainder n w‖≤(δ : ℝ)*‖v-w‖
  zero : ∀ n, remainder n 0=0

variable {ℓ δ : ℝ≥0}
def LocalRecurrence.step (r : LocalRecurrence ℓ δ) (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 LocalRecurrence.extend (r : LocalRecurrence ℓ δ) : Recurrence ℓ δ where
  a := r.a
  b := r.b
  remainder n v := r.remainder n (planeClip v)
  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
    have hh := r.local_lipschitz n (planeClip v) (planeClip w) (norm_planeClip_le v) (norm_planeClip_le w)
    have he := planeClip_lipschitz.dist_le_mul v w
    simp only [dist_eq_norm,NNReal.coe_one,one_mul] at he ⊢
    exact hh.trans (mul_le_mul_of_nonneg_left he δ.coe_nonneg)
  zero n := by rw [planeClip_zero,r.zero]

lemma extend_step_eq (r : LocalRecurrence ℓ δ) (n : ℕ) {v : Plane} (hv : ‖v‖≤1) :
    r.extend.step n v=r.step n v := by
  simp only [LocalRecurrence.extend,Recurrence.step,LocalRecurrence.step,planeClip_eq hv]

lemma local_solution_bound (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1) {s : ℝ} (hs : |s|≤1) (n : ℕ) :
    ‖r.extend.solution h s n‖≤1 :=
  ((r.extend.solution h s).norm_coe_le_norm n).trans ((solution_norm_bound _ h s).trans hs)
lemma local_solution_orbit (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1) {s : ℝ} (hs : |s|≤1) (n : ℕ) :
    r.extend.solution h s (n+1)=r.step n (r.extend.solution h s n) := by
  rw [solution_orbit,extend_step_eq r n (local_solution_bound r h hs n)]

theorem local_stable_graph (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1) :
    ∃ g : ℝ → ℝ, g 0=0 ∧ LipschitzWith 1 g ∧
      ∀ s : ℝ, |s|≤1 → ∃ x : ℕ → Plane, x 0=(s,g s) ∧
        (∀ n, x (n+1)=r.step n (x n)) ∧
        (∀ n, ‖x n‖≤((ℓ+δ : ℝ≥0) : ℝ)^n*|s|) := by
  refine ⟨r.extend.graph h,graph_zero _ h,graph_lipschitz _ h,fun s hs =>
    ⟨r.extend.solution h s,Prod.ext (solution_initial _ h s) rfl,local_solution_orbit r h hs,?_⟩⟩
  intro n
  simpa [solution_zero] using solution_exponential_contraction r.extend h s 0 n

end StandardMapEntropy.NonlinearStable

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology NNReal ENNReal

noncomputable def hyperbolicChartRate (χ : ℝ) : ℝ := Real.exp (-χ/2)
noncomputable def hyperbolicChartError (χ : ℝ) : ℝ := (1-hyperbolicChartRate χ)/2
noncomputable def hyperbolicChartScale (k χ : ℝ) : ℝ :=
  hyperbolicChartError χ/(8*(1+derivativeVariationBound k)*Real.exp χ)
lemma hyperbolicChartRate_pos (χ : ℝ) : 0<hyperbolicChartRate χ := Real.exp_pos _
lemma hyperbolicChartRate_lt_one {χ : ℝ} (hχ : 0<χ) : hyperbolicChartRate χ<1 := by
  apply Real.exp_lt_one_iff.mpr
  linarith
lemma hyperbolicChartError_pos {χ : ℝ} (hχ : 0<χ) : 0<hyperbolicChartError χ := by
  have hh := hyperbolicChartRate_lt_one hχ
  unfold hyperbolicChartError
  linarith
lemma hyperbolicChartScale_pos (k : ℝ) {χ : ℝ} (hχ : 0<χ) : 0<hyperbolicChartScale k χ := by
  exact div_pos (hyperbolicChartError_pos hχ)
    (mul_pos (mul_pos (by norm_num) (by linarith [derivativeVariationBound_nonneg k])) (Real.exp_pos χ))
lemma hyperbolicChartScale_le {k χ : ℝ} (hχ : 0<χ) : hyperbolicChartScale k χ≤1/16 := by
  have hD := derivativeVariationBound_nonneg k
  have hE : 1≤Real.exp χ := Real.one_le_exp_iff.mpr hχ.le
  have he : hyperbolicChartError χ≤1/2 := by
    unfold hyperbolicChartError
    linarith [hyperbolicChartRate_pos χ]
  have hden : 8≤8*(1+derivativeVariationBound k)*Real.exp χ := by nlinarith
  apply (div_le_iff₀ (lt_of_lt_of_le (by norm_num : (0 : ℝ)<8) hden)).mpr
  nlinarith

noncomputable def chartSize (k χ : ℝ) (z : Torus) : ℝ :=
  hyperbolicChartScale k χ*chartRadius k χ (χ/2) z
noncomputable def actualChartFrame (k χ : ℝ) (z : Torus) : RealPlane →L[ℝ] ℂ :=
  flatFrame (chartSize k χ z) (lyapunovFrame k χ z)
noncomputable def actualChartInverse (k χ : ℝ) (z : Torus) : ℂ →L[ℝ] RealPlane :=
  flatInverse (chartSize k χ z) (lyapunovCoframe k χ z)
noncomputable def actualStableMultiplier (k χ : ℝ) (z : Torus) : ℝ :=
  chartSize k χ z/chartSize k χ (standardMap k z)*stableMultiplier k χ z
noncomputable def actualUnstableMultiplier (k χ : ℝ) (z : Torus) : ℝ :=
  chartSize k χ z/chartSize k χ (standardMap k z)*unstableMultiplier k χ z
lemma chartSize_pos (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus) : 0<chartSize k χ z :=
  mul_pos (hyperbolicChartScale_pos k hχ) (chartRadius_pos k χ (χ/2) z)
lemma chartSize_le_scale (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus) :
    chartSize k χ z≤hyperbolicChartScale k χ := by
  exact (mul_le_mul_of_nonneg_left (chartRadius_le_one k χ (χ/2) z)
    (hyperbolicChartScale_pos k hχ).le).trans_eq (mul_one _)
lemma actualChartFrame_norm_le (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus) :
    ‖actualChartFrame k χ z‖≤2*chartSize k χ z :=
  flatFrame_norm_le (chartSize_pos k hχ z).le (lyapunovFrame_norm_le k χ z)
lemma actualChartInverse_frame (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hw : wedge (stableVector k z) (unstableVector k z)≠0) (v : RealPlane) :
    actualChartInverse k χ z (actualChartFrame k χ z v)=v :=
  flatInverse_frame (ne_of_gt (chartSize_pos k hχ z)) (lyapunovCoframe_frame k χ z hw) v
lemma actualChartFrame_inverse (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hw : wedge (stableVector k z) (unstableVector k z)≠0) (v : ℂ) :
    actualChartFrame k χ z (actualChartInverse k χ z v)=v :=
  flatFrame_inverse (ne_of_gt (chartSize_pos k hχ z)) (lyapunovFrame_coframe k χ z hw) v

def RegularChartPoint (k χ : ℝ) (z : Torus) : Prop :=
  wedge (stableVector k z) (unstableVector k z)≠0 ∧
  (lyapunovCoframe k χ (standardMap k z)).comp
    ((standardDerivative k z).comp (lyapunovFrame k χ z)) =
      diagonalPlane (stableMultiplier k χ z) (unstableMultiplier k χ z) ∧
  |stableMultiplier k χ z|≤Real.exp (-χ) ∧
  Real.exp χ≤|unstableMultiplier k χ z| ∧
  chartRadius k χ (χ/2) z*‖lyapunovCoframe k χ z‖≤1 ∧
  Real.exp (-(χ/2))*chartRadius k χ (χ/2) z≤chartRadius k χ (χ/2) (standardMap k z) ∧
  Real.exp (-(χ/2))*chartRadius k χ (χ/2) (standardMap k z)≤chartRadius k χ (χ/2) z

lemma ae_regularChartPoint (k : ℝ) (hk : 0≤k) {χ : ℝ} (hχ : 0<χ) :
    ∀ᵐ z ∂area.restrict (spectralGapRegion k hk χ), RegularChartPoint k χ z := by
  filter_upwards [ae_restrict_mem (measurableSet_spectralGapRegion k hk χ),
    (ae_transverseLines k hk).filter_mono Measure.absolutelyContinuous_restrict.ae_le,
    ae_lyapunov_normal_form k hk χ hχ.le,ae_stableMultiplier_bound k hk χ hχ.le,
    ae_unstableMultiplier_bound k hk χ hχ.le,ae_chartRadius_control k hk χ hχ.le (χ/2) (by linarith)]
    with z hz ht hn hs hu hr
  exact ⟨ht (hχ.trans hz),hn,hs,hu,hr⟩

lemma ae_regularChartPoint_all_iterates (k : ℝ) (hk : 0≤k) {χ : ℝ} (hχ : 0<χ) :
    ∀ᵐ z ∂area.restrict (spectralGapRegion k hk χ),
      ∀ n : ℕ, RegularChartPoint k χ ((standardMap k)^[n] z) ∧
        RegularChartPoint k χ ((inverseMap k)^[n] z) := by
  rw [ae_all_iff]
  intro n
  exact (((measurePreserving_spectralGapRegion k hk χ).iterate n).quasiMeasurePreserving.ae
    (ae_regularChartPoint k hk hχ)).and
    (((measurePreserving_inverse_spectralGapRegion k hk χ).iterate n).quasiMeasurePreserving.ae
    (ae_regularChartPoint k hk hχ))

lemma slow_radius_ratio {a b ε : ℝ} (_ha : 0<a) (hb : 0<b)
    (hab : Real.exp (-ε)*a≤b) : a/b≤Real.exp ε := by
  apply (div_le_iff₀ hb).mpr
  have hh := mul_le_mul_of_nonneg_left hab (Real.exp_pos ε).le
  have he : Real.exp ε*Real.exp (-ε)=1 := by rw [←Real.exp_add,add_neg_cancel,Real.exp_zero]
  simpa only [←mul_assoc,he,one_mul] using hh

lemma chartSize_ratio (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z w : Torus) :
    chartSize k χ z/chartSize k χ w=chartRadius k χ (χ/2) z/chartRadius k χ (χ/2) w := by
  unfold chartSize
  rw [mul_div_mul_left _ _ (ne_of_gt (hyperbolicChartScale_pos k hχ))]

lemma actualStableMultiplier_bound (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hz : RegularChartPoint k χ z) : |actualStableMultiplier k χ z|≤hyperbolicChartRate χ := by
  have hr := slow_radius_ratio (chartRadius_pos k χ (χ/2) z)
    (chartRadius_pos k χ (χ/2) (standardMap k z)) hz.2.2.2.2.2.1
  have he : Real.exp (χ/2)*Real.exp (-χ)=hyperbolicChartRate χ := by
    rw [←Real.exp_add]
    congr 1
    ring
  unfold actualStableMultiplier
  rw [abs_mul,abs_of_pos (div_pos (chartSize_pos k hχ z) (chartSize_pos k hχ _)),chartSize_ratio k hχ]
  exact (mul_le_mul hr hz.2.2.1 (abs_nonneg _) (Real.exp_pos _).le).trans_eq he

lemma actualUnstableMultiplier_ne (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hz : RegularChartPoint k χ z) : actualUnstableMultiplier k χ z≠0 := by
  have hb : unstableMultiplier k χ z≠0 := abs_pos.mp ((Real.exp_pos χ).trans_le hz.2.2.2.1)
  exact mul_ne_zero (div_ne_zero (ne_of_gt (chartSize_pos k hχ z)) (ne_of_gt (chartSize_pos k hχ _))) hb

lemma actualUnstableMultiplier_inverse_bound (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hz : RegularChartPoint k χ z) : |(actualUnstableMultiplier k χ z)⁻¹|≤hyperbolicChartRate χ := by
  have hr := slow_radius_ratio (chartRadius_pos k χ (χ/2) (standardMap k z))
    (chartRadius_pos k χ (χ/2) z) hz.2.2.2.2.2.2
  have hb : |unstableMultiplier k χ z|⁻¹≤Real.exp (-χ) := by
    rw [Real.exp_neg]
    exact inv_anti₀ (Real.exp_pos χ) hz.2.2.2.1
  have he : Real.exp (χ/2)*Real.exp (-χ)=hyperbolicChartRate χ := by
    rw [←Real.exp_add]
    congr 1
    ring
  unfold actualUnstableMultiplier
  rw [abs_inv,abs_mul,abs_of_pos (div_pos (chartSize_pos k hχ z) (chartSize_pos k hχ _)),
    mul_inv,inv_div,chartSize_ratio k hχ]
  exact (mul_le_mul hr hb (inv_nonneg.mpr (abs_nonneg _)) (Real.exp_pos _).le).trans_eq he

end StandardMapEntropy

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology NNReal ENNReal

lemma chart_nonlinearity_coefficient (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : Torus)
    (hz : RegularChartPoint k χ z) (hn : RegularChartPoint k χ (standardMap k z)) :
    ‖actualChartInverse k χ (standardMap k z)‖*derivativeVariationBound k*
      ‖actualChartFrame k χ z‖^2≤hyperbolicChartError χ := by
  let a := chartRadius k χ (χ/2) z
  let b := chartRadius k χ (χ/2) (standardMap k z)
  let c := ‖lyapunovCoframe k χ (standardMap k z)‖
  let η := hyperbolicChartScale k χ
  have ha : 0<a := chartRadius_pos k χ (χ/2) z
  have hb : 0<b := chartRadius_pos k χ (χ/2) (standardMap k z)
  have hη : 0<η := hyperbolicChartScale_pos k hχ
  have hc : 0≤c := norm_nonneg _
  have hbc : b*c≤1 := hn.2.2.2.2.1
  have hab : a/b≤Real.exp (χ/2) := slow_radius_ratio ha hb hz.2.2.2.2.2.1
  have hD := derivativeVariationBound_nonneg k
  have hF : ‖actualChartFrame k χ z‖≤2*(η*a) := actualChartFrame_norm_le k hχ z
  have hC : ‖actualChartInverse k χ (standardMap k z)‖≤(η*b)⁻¹*c :=
    flatInverse_norm_le (chartSize_pos k hχ _).le _
  have hEF : (Real.exp (χ/2))^2=Real.exp χ := by
    rw [pow_two,←Real.exp_add]
    congr 1
    ring
  have hsqr : (a/b)^2≤Real.exp χ := by
    rw [←hEF]
    exact pow_le_pow_left₀ (div_nonneg ha.le hb.le) hab 2
  calc
    _ ≤ ((η*b)⁻¹*c)*derivativeVariationBound k*(2*(η*a))^2 :=
      mul_le_mul (mul_le_mul_of_nonneg_right hC hD)
        (pow_le_pow_left₀ (norm_nonneg _) hF 2) (sq_nonneg _)
        (mul_nonneg (mul_nonneg (inv_nonneg.mpr (mul_nonneg hη.le hb.le)) hc) hD)
    _ = (4*derivativeVariationBound k*η)*((b*c)*(a/b)^2) := by
      field_simp [ne_of_gt hη,ne_of_gt hb]
      ring
    _ ≤ (4*derivativeVariationBound k*η)*(1*Real.exp χ) :=
      mul_le_mul_of_nonneg_left (mul_le_mul hbc hsqr (sq_nonneg _) (by norm_num)) (by positivity)
    _ = hyperbolicChartError χ*(derivativeVariationBound k/(2*(1+derivativeVariationBound k))) := by
      dsimp [η,hyperbolicChartScale]
      field_simp [ne_of_gt (Real.exp_pos χ),ne_of_gt (show 0<1+derivativeVariationBound k by linarith)]
      ring
    _ ≤ hyperbolicChartError χ*1 := by
      apply mul_le_mul_of_nonneg_left _ (hyperbolicChartError_pos hχ).le
      apply (div_le_iff₀ (show 0<2*(1+derivativeVariationBound k) by linarith)).mpr
      linarith
    _ = _ := mul_one _

noncomputable def actualChartRemainder (k χ : ℝ) (z : ℂ) : RealPlane → RealPlane :=
  flatRemainder k z (actualChartFrame k χ (complexProjection z))
    (actualChartInverse k χ (standardMap k (complexProjection z)))
@[simp] lemma actualChartRemainder_zero (k χ : ℝ) (z : ℂ) : actualChartRemainder k χ z 0=0 :=
  flatRemainder_zero _ _ _ _
lemma actualChartRemainder_lipschitz (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : ℂ)
    (hz : RegularChartPoint k χ (complexProjection z))
    (hn : RegularChartPoint k χ (standardMap k (complexProjection z)))
    {v w : RealPlane} (hv : ‖v‖≤1) (hw : ‖w‖≤1) :
    ‖actualChartRemainder k χ z v-actualChartRemainder k χ z w‖≤hyperbolicChartError χ*‖v-w‖ :=
  (flatRemainder_sub_bound k z _ _ hv hw).trans
    (mul_le_mul_of_nonneg_right (chart_nonlinearity_coefficient k hχ _ hz hn) (norm_nonneg _))

lemma actualChart_derivative_diagonal (k χ : ℝ) (z : Torus) (hz : RegularChartPoint k χ z) (v : RealPlane) :
    actualChartInverse k χ (standardMap k z) (standardDerivative k z (actualChartFrame k χ z v)) =
      (actualStableMultiplier k χ z*v.1,actualUnstableMultiplier k χ z*v.2) :=
  flat_diagonal _ _ _ hz.2.1 v

lemma actualChart_step (k χ : ℝ) (z : ℂ) (hz : RegularChartPoint k χ (complexProjection z)) (v : RealPlane) :
    actualChartInverse k χ (standardMap k (complexProjection z))
      (standardLift k (z+actualChartFrame k χ (complexProjection z) v)-standardLift k z) =
      (actualStableMultiplier k χ (complexProjection z)*v.1+(actualChartRemainder k χ z v).1,
        actualUnstableMultiplier k χ (complexProjection z)*v.2+(actualChartRemainder k χ z v).2) := by
  have hdiff : standardLift k (z+actualChartFrame k χ (complexProjection z) v)-standardLift k z =
      standardDerivative k (complexProjection z) (actualChartFrame k χ (complexProjection z) v)+
        liftRemainder k z (actualChartFrame k χ (complexProjection z) v) := by
    unfold liftRemainder
    abel
  rw [hdiff,map_add,actualChart_derivative_diagonal k χ _ hz]
  rfl

lemma actualChart_lift_step (k : ℝ) {χ : ℝ} (hχ : 0<χ) (z : ℂ)
    (hz : RegularChartPoint k χ (complexProjection z))
    (hn : RegularChartPoint k χ (standardMap k (complexProjection z))) (v : RealPlane) :
    standardLift k (z+actualChartFrame k χ (complexProjection z) v) = standardLift k z+
      actualChartFrame k χ (standardMap k (complexProjection z))
        (actualStableMultiplier k χ (complexProjection z)*v.1+(actualChartRemainder k χ z v).1,
          actualUnstableMultiplier k χ (complexProjection z)*v.2+(actualChartRemainder k χ z v).2) := by
  have hh := congrArg (actualChartFrame k χ (standardMap k (complexProjection z))) (actualChart_step k χ z hz v)
  rw [actualChartFrame_inverse k hχ _ hn.1] at hh
  exact (sub_eq_iff_eq_add.mp hh).trans (add_comm _ _)

end StandardMapEntropy

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology NNReal ENNReal
open NonlinearStable

noncomputable def chartLinearRate (χ : ℝ) : ℝ≥0 := ⟨hyperbolicChartRate χ,(hyperbolicChartRate_pos χ).le⟩
noncomputable def chartErrorRate (χ : ℝ) (hχ : 0<χ) : ℝ≥0 := ⟨hyperbolicChartError χ,(hyperbolicChartError_pos hχ).le⟩
lemma chart_rates_contract {χ : ℝ} (hχ : 0<χ) : chartLinearRate χ+chartErrorRate χ hχ<1 := by
  change hyperbolicChartRate χ+hyperbolicChartError χ<1
  unfold hyperbolicChartError
  linarith [hyperbolicChartRate_lt_one hχ]

lemma regular_lift_next (k χ : ℝ) (w : ℂ)
    (hw : ∀ n : ℕ, RegularChartPoint k χ (complexProjection ((standardLift k)^[n] w))) (n : ℕ) :
    RegularChartPoint k χ (standardMap k (complexProjection ((standardLift k)^[n] w))) := by
  simpa only [Function.iterate_succ_apply',complexProjection_standardLift] using hw (n+1)

noncomputable def actualLocalRecurrence (k : ℝ) (χ : ℝ) (hχ : 0<χ) (w : ℂ)
    (hw : ∀ n : ℕ, RegularChartPoint k χ (complexProjection ((standardLift k)^[n] w))) :
    LocalRecurrence (chartLinearRate χ) (chartErrorRate χ hχ) where
  a n := actualStableMultiplier k χ (complexProjection ((standardLift k)^[n] w))
  b n := actualUnstableMultiplier k χ (complexProjection ((standardLift k)^[n] w))
  remainder n := actualChartRemainder k χ ((standardLift k)^[n] w)
  stable_bound n := actualStableMultiplier_bound k hχ _ (hw n)
  inverse_bound n := actualUnstableMultiplier_inverse_bound k hχ _ (hw n)
  b_ne n := actualUnstableMultiplier_ne k hχ _ (hw n)
  local_lipschitz n _ _ hv hu := actualChartRemainder_lipschitz k hχ _ (hw n) (regular_lift_next k χ w hw n) hv hu
  zero _ := actualChartRemainder_zero _ _ _

lemma actualLocalRecurrence_lift_step (k : ℝ) (χ : ℝ) (hχ : 0<χ) (w : ℂ)
    (hw : ∀ n : ℕ, RegularChartPoint k χ (complexProjection ((standardLift k)^[n] w)))
    (n : ℕ) (v : RealPlane) :
    standardLift k ((standardLift k)^[n] w+actualChartFrame k χ (complexProjection ((standardLift k)^[n] w)) v) =
      (standardLift k)^[n+1] w+actualChartFrame k χ (complexProjection ((standardLift k)^[n+1] w))
        ((actualLocalRecurrence k χ hχ w hw).step n v) := by
  simpa only [Function.iterate_succ_apply',complexProjection_standardLift,actualLocalRecurrence,LocalRecurrence.step] using
    actualChart_lift_step k hχ ((standardLift k)^[n] w) (hw n) (regular_lift_next k χ w hw n) v

lemma actual_local_orbit_lift (k : ℝ) (χ : ℝ) (hχ : 0<χ) (w : ℂ)
    (hw : ∀ n : ℕ, RegularChartPoint k χ (complexProjection ((standardLift k)^[n] w)))
    (x : ℕ → RealPlane) (hx : ∀ n, x (n+1)=(actualLocalRecurrence k χ hχ w hw).step n (x n)) (n : ℕ) :
    (standardLift k)^[n] (w+actualChartFrame k χ (complexProjection w) (x 0)) =
      (standardLift k)^[n] w+actualChartFrame k χ (complexProjection ((standardLift k)^[n] w)) (x n) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [Function.iterate_succ_apply',ih,actualLocalRecurrence_lift_step k χ hχ w hw n,←hx n]

theorem actual_stable_curve_of_regular (k : ℝ) (χ : ℝ) (hχ : 0<χ) (w : ℂ)
    (hw : ∀ n : ℕ, RegularChartPoint k χ (complexProjection ((standardLift k)^[n] w))) :
    ∃ γ : ℝ → ℂ, γ 0=w ∧ Continuous γ ∧ Function.Injective γ ∧
      ∀ s t : ℝ, |s|≤1 → |t|≤1 → ∀ n : ℕ,
        ‖(standardLift k)^[n] (γ s)-(standardLift k)^[n] (γ t)‖≤
          (2*hyperbolicChartScale k χ)*
            (hyperbolicChartRate χ+hyperbolicChartError χ)^n*|s-t| := by
  let r := actualLocalRecurrence k χ hχ w hw
  let h := chart_rates_contract hχ
  let g := r.extend.graph h
  let γ : ℝ → ℂ := fun s => w+actualChartFrame k χ (complexProjection w) (s,g s)
  have g0 : g 0=0 := graph_zero r.extend h
  have gc : Continuous g := (graph_lipschitz r.extend h).continuous
  have hinit (s : ℝ) : r.extend.solution h s 0=(s,g s) := Prod.ext (solution_initial _ h s) rfl
  have horbit (s : ℝ) (hs : |s|≤1) (n : ℕ) :
      (standardLift k)^[n] (γ s)=(standardLift k)^[n] w+
        actualChartFrame k χ (complexProjection ((standardLift k)^[n] w)) (r.extend.solution h s n) := by
    have hh := actual_local_orbit_lift k χ hχ w hw (r.extend.solution h s) (local_solution_orbit r h hs) n
    simpa only [hinit,γ] using hh
  refine ⟨γ,?_,?_,?_,?_⟩
  · simp only [γ,g0,Prod.mk_zero_zero,map_zero,add_zero]
  · exact continuous_const.add ((actualChartFrame k χ (complexProjection w)).continuous.comp (continuous_id.prodMk gc))
  · intro s t he
    have he' : actualChartFrame k χ (complexProjection w) (s,g s)=
        actualChartFrame k χ (complexProjection w) (t,g t) := add_left_cancel he
    have hp := congrArg (actualChartInverse k χ (complexProjection w)) he'
    have hw0 : RegularChartPoint k χ (complexProjection w) := by simpa only [Function.iterate_zero, id_eq] using hw 0
    rw [actualChartInverse_frame k hχ _ hw0.1,actualChartInverse_frame k hχ _ hw0.1] at hp
    exact congrArg Prod.fst hp
  · intro s t hs ht n
    rw [horbit s hs n,horbit t ht n,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 r.extend h s t n
    calc
      _ ≤ ‖actualChartFrame k χ (complexProjection ((standardLift k)^[n] w))‖*
          ‖r.extend.solution h s n-r.extend.solution h t n‖ := ContinuousLinearMap.le_opNorm _ _
      _ ≤ (2*hyperbolicChartScale k χ)*
          (((chartLinearRate χ+chartErrorRate χ hχ : ℝ≥0) : ℝ)^n*|s-t|) :=
        mul_le_mul hn hx (norm_nonneg _) (by linarith [hyperbolicChartScale_pos k hχ])
      _ = _ := by
        change (2*hyperbolicChartScale k χ)*((hyperbolicChartRate χ+hyperbolicChartError χ)^n*|s-t|)=_
        ring

theorem ae_actual_stable_curve (k : ℝ) (hk : 0≤k) (χ : ℝ) (hχ : 0<χ) :
    ∀ᵐ z ∂area.restrict (spectralGapRegion k hk χ), ∀ w : ℂ, complexProjection w=z →
      ∃ γ : ℝ → ℂ, γ 0=w ∧ Continuous γ ∧ Function.Injective γ ∧
        ∀ 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
  apply actual_stable_curve_of_regular k χ hχ w
  intro n
  simpa only [complexProjection_iterate,hw] using (hz n).1

end StandardMapEntropy

end
section
namespace StandardMapEntropy.NonlinearStable
open Filter
open scoped Topology NNReal
variable {ℓ δ : ℝ≥0}

noncomputable def sndSequence (x : Sequence) : BoundedContinuousFunction ℕ ℝ :=
  BoundedContinuousFunction.ofNormedAddCommGroupDiscrete (fun n => (x n).2) ‖x‖
    (fun n => (norm_snd_le (x n)).trans (x.norm_coe_le_norm n))
@[simp] lemma sndSequence_apply (x : Sequence) (n : ℕ) : sndSequence x n=(x n).2 := rfl

lemma linearRate_lt_one (h : ℓ+δ<1) : (ℓ : ℝ)<1 := by
  have he : ℓ≤ℓ+δ := le_add_of_nonneg_right (show (0 : ℝ≥0)≤δ from bot_le)
  exact lt_of_le_of_lt he h

lemma solution_snd_bound_of_forcing (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ)
    {B : ℝ} (hB : 0≤B)
    (hr : ∀ n, ‖r.remainder n (r.solution h s n)-r.remainder n (r.solution h t n)‖≤B) :
    ‖sndSequence (r.solution h s)-sndSequence (r.solution h t)‖≤(ℓ : ℝ)*B/(1-(ℓ : ℝ)) := by
  let U := ‖sndSequence (r.solution h s)-sndSequence (r.solution h t)‖
  have hU : 0≤U := norm_nonneg _
  have hcon : U≤(ℓ : ℝ)*(U+B) := by
    apply (BoundedContinuousFunction.norm_le (mul_nonneg ℓ.coe_nonneg (add_nonneg hU hB))).mpr
    intro n
    have hs := congrArg (fun x : Sequence => (x n).2) (solution_fixed r h s)
    have ht := congrArg (fun x : Sequence => (x n).2) (solution_fixed r h t)
    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 hs
    change (r.b n)⁻¹*((r.solution h t (n+1)).2-(r.remainder n (r.solution h t n)).2)=
      (r.solution h t n).2 at ht
    change |(r.solution h s n).2-(r.solution h t n).2|≤_
    rw [←hs,←ht]
    have hu : |(r.solution h s (n+1)).2-(r.solution h t (n+1)).2|≤U :=
      (sndSequence (r.solution h s)-sndSequence (r.solution h t)).norm_coe_le_norm (n+1)
    have hb : |(r.remainder n (r.solution h s n)).2-(r.remainder n (r.solution h t n)).2|≤B :=
      (norm_snd_le _).trans (hr n)
    calc
      _ = |(r.b n)⁻¹| * |((r.solution h s (n+1)).2-(r.solution h t (n+1)).2)-
          ((r.remainder n (r.solution h s n)).2-(r.remainder n (r.solution h t n)).2)| := by
        rw [←abs_mul]; congr 1; ring
      _ ≤ |(r.b n)⁻¹| * (|(r.solution h s (n+1)).2-(r.solution h t (n+1)).2|+
          |(r.remainder n (r.solution h s n)).2-(r.remainder n (r.solution h t n)).2|) :=
        mul_le_mul_of_nonneg_left (abs_sub _ _) (abs_nonneg _)
      _ ≤ _ := mul_le_mul (r.inverse_bound n) (add_le_add hu hb) (by positivity) ℓ.coe_nonneg
  apply (le_div_iff₀ (sub_pos.mpr (linearRate_lt_one h))).mpr
  dsimp [U] at hcon ⊢
  nlinarith

lemma graph_slope_bound (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s t : ℝ) :
    |r.graph h s-r.graph h t|≤((ℓ : ℝ)*(δ : ℝ)/(1-(ℓ : ℝ)))*|s-t| := by
  have hforce (n : ℕ) : ‖r.remainder n (r.solution h s n)-r.remainder n (r.solution h t n)‖≤
      (δ : ℝ)*|s-t| :=
    (remainder_sub_bound r _ _ n).trans (mul_le_mul_of_nonneg_left (solution_lipschitz r h s t) δ.coe_nonneg)
  have hh := solution_snd_bound_of_forcing r h s t (mul_nonneg δ.coe_nonneg (abs_nonneg _)) hforce
  have hb := (sndSequence (r.solution h s)-sndSequence (r.solution h t)).norm_coe_le_norm 0
  apply hb.trans
  exact hh.trans_eq (by ring)

lemma graph_bound_of_forcing (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ)
    {B : ℝ} (hB : 0≤B) (hr : ∀ n, ‖r.remainder n (r.solution h s n)‖≤B) :
    |r.graph h s|≤(ℓ : ℝ)*B/(1-(ℓ : ℝ)) := by
  have hr' (n : ℕ) : ‖r.remainder n (r.solution h s n)-r.remainder n (r.solution h 0 n)‖≤B := by
    simpa [solution_zero,r.zero] using hr n
  have hh := solution_snd_bound_of_forcing r h s 0 hB hr'
  have hb := (sndSequence (r.solution h s)-sndSequence (r.solution h 0)).norm_coe_le_norm 0
  have hle := hb.trans hh
  simpa [Recurrence.graph,solution_zero,sndSequence_apply] using hle

lemma local_graph_quadratic_bound (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1)
    {B : ℝ} (hB : 0≤B)
    (hr : ∀ n (v : Plane), ‖v‖≤1 → ‖r.remainder n v‖≤B*‖v‖^2)
    {s : ℝ} (hs : |s|≤1) :
    |r.extend.graph h s|≤((ℓ : ℝ)*B/(1-(ℓ : ℝ)))*|s|^2 := by
  have hforce (n : ℕ) : ‖r.extend.remainder n (r.extend.solution h s n)‖≤B*|s|^2 := by
    change ‖r.remainder n (planeClip (r.extend.solution h s n))‖≤_
    rw [planeClip_eq (local_solution_bound r h hs n)]
    apply (hr n _ (local_solution_bound r h hs n)).trans
    exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (norm_nonneg _)
      (((r.extend.solution h s).norm_coe_le_norm n).trans (solution_norm_bound _ h s)) 2) hB
  exact (graph_bound_of_forcing _ h s (mul_nonneg hB (sq_nonneg _)) hforce).trans_eq (by ring)

end StandardMapEntropy.NonlinearStable

end
end

end OAI