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