import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Holonomy.DerivativeQuantitative

namespace OAI

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

lemma Recurrence.stable_cone_backward (r : Recurrence ℓ δ) (h : ℓ+δ<1) (n : ℕ) (v : Plane)
    (hv : |(r.step n v).2|≤|(r.step n v).1|) :
    |v.2|≤|v.1| ∧ ‖r.step n v‖≤((ℓ+δ : ℝ≥0) : ℝ)*‖v‖ := by
  let q : ℝ := ((ℓ+δ : ℝ≥0) : ℝ)
  have hq0 : 0≤q := (ℓ+δ).coe_nonneg
  have hq1 : q<1 := h
  have hn : ‖r.step n v‖=|(r.step n v).1| := max_eq_left hv
  have hf : ‖r.step n v‖≤q*‖v‖ := by
    rw [hn]
    simpa only [r.step_zero,Prod.fst_zero,sub_zero] using step_fst_sub_bound r n v 0
  refine ⟨?_,hf⟩
  by_contra hc
  have hc' : |v.1| < |v.2| := lt_of_not_ge hc
  have hp : 0<‖v‖ := by
    rw [show ‖v‖=|v.2| from max_eq_right hc'.le]
    exact (abs_nonneg _).trans_lt hc'
  have hb := (r.unstable_cone_step h n v 0 (by simpa only [Prod.fst_zero,Prod.snd_zero,sub_zero] using hc'.le)).2
  simp only [r.step_zero,Prod.snd_zero,sub_zero] at hb
  have hnb : ‖v‖≤q*‖r.step n v‖ := by
    rw [show ‖v‖=|v.2| from max_eq_right hc'.le]
    have hsnd : |(r.step n v).2|≤‖r.step n v‖ := norm_snd_le (r.step n v)
    exact hb.trans (mul_le_mul_of_nonneg_left hsnd hq0)
  have hh := mul_le_mul_of_nonneg_left hf hq0
  have hsqr : q*q<1 := by nlinarith
  nlinarith

lemma Recurrence.stable_orbit_bound (r : Recurrence ℓ δ) (h : ℓ+δ<1) (v : Plane) (n : ℕ)
    (hv : |(r.orbit v n).2|≤|(r.orbit v n).1|) :
    ‖r.orbit v n‖≤((ℓ+δ : ℝ≥0) : ℝ)^n*‖v‖ := by
  induction n with
  | zero => simp only [Recurrence.orbit,pow_zero,one_mul,le_refl]
  | succ n ih =>
    have hh := r.stable_cone_backward h n (r.orbit v n) hv
    exact hh.2.trans ((mul_le_mul_of_nonneg_left (ih hh.1) (ℓ+δ).coe_nonneg).trans_eq (by rw [pow_succ]; ring))

lemma Recurrence.unstable_orbit_bound (r : Recurrence ℓ δ) (h : ℓ+δ<1) (v : Plane)
    (hv : |v.1|≤|v.2|) (n : ℕ) :
    ‖v‖≤((ℓ+δ : ℝ≥0) : ℝ)^n*‖r.orbit v n‖ := by
  induction n with
  | zero => simp only [Recurrence.orbit,pow_zero,one_mul,le_refl]
  | succ n ih =>
    have hh := (r.orbit_cone h hv n).2
    rw [←r.orbit_norm_eq_snd h hv n,←r.orbit_norm_eq_snd h hv (n+1)] at hh
    exact ih.trans ((mul_le_mul_of_nonneg_left hh (pow_nonneg (ℓ+δ).coe_nonneg n)).trans_eq (by rw [pow_succ]; ring))

lemma Recurrence.orbit_tail (r : Recurrence ℓ δ) (v : Plane) (j n : ℕ) :
    (r.tail j).orbit (r.orbit v j) n=r.orbit v (j+n) := by
  induction n with
  | zero => simp only [Recurrence.orbit,Nat.add_zero]
  | succ n ih =>
    rw [Recurrence.orbit,Nat.add_succ,Recurrence.orbit,ih]
    rfl

lemma Recurrence.trappedBox_two_ended (r : Recurrence ℓ δ) (h : ℓ+δ<1) {N : ℕ} {v : Plane}
    (hv : v∈r.trappedBox N) {j : ℕ} (hj : j≤N) :
    ‖r.orbit v j‖≤((ℓ+δ : ℝ≥0) : ℝ)^j+((ℓ+δ : ℝ≥0) : ℝ)^(N-j) := by
  rcases le_total |(r.orbit v j).1| |(r.orbit v j).2| with hc|hc
  · have hh := (r.tail j).unstable_orbit_bound h (r.orbit v j) hc (N-j)
    rw [r.orbit_tail,Nat.add_sub_of_le hj] at hh
    have he := hh.trans ((mul_le_mul_of_nonneg_left (hv N le_rfl) (pow_nonneg (ℓ+δ).coe_nonneg _)).trans_eq (mul_one _))
    exact he.trans (le_add_of_nonneg_left (pow_nonneg (ℓ+δ).coe_nonneg j))
  · have hh := r.stable_orbit_bound h v j hc
    have he := hh.trans ((mul_le_mul_of_nonneg_left (hv 0 (Nat.zero_le N)) (pow_nonneg (ℓ+δ).coe_nonneg _)).trans_eq (mul_one _))
    exact he.trans (le_add_of_nonneg_right (pow_nonneg (ℓ+δ).coe_nonneg (N-j)))

lemma geometric_partial_bound {q : ℝ} (hq0 : 0≤q) (hq1 : q<1) (N : ℕ) :
    (∑ j ∈ Finset.range N,q^j)≤1/(1-q) := by
  apply (le_div_iff₀ (sub_pos.mpr hq1)).mpr
  rw [geom_sum_mul_neg]
  linarith [pow_nonneg hq0 N]

lemma Recurrence.trappedBox_sum_norm (r : Recurrence ℓ δ) (h : ℓ+δ<1) {N : ℕ} {v : Plane}
    (hv : v∈r.trappedBox N) :
    (∑ j ∈ Finset.range N,‖r.orbit v j‖)≤2/(1-((ℓ+δ : ℝ≥0) : ℝ)) := by
  let q : ℝ := ((ℓ+δ : ℝ≥0) : ℝ)
  have hq0 : 0≤q := (ℓ+δ).coe_nonneg
  have hq1 : q<1 := h
  have hb : (∑ j ∈ Finset.range N,q^(N-j))≤1/(1-q) := by
    have hh := StandardMapEntropy.sum_of_backward_contraction (fun j => q^(N-j)) (fun _ => pow_nonneg hq0 _)
      hq0 hq1 N (fun j hj => ?_)
    · simpa only [Nat.sub_self,pow_zero] using hh
    · have he : N-j=N-(j+1)+1 := by omega
      rw [he,pow_succ]
      exact le_of_eq (mul_comm _ _)
  calc
    _ ≤ ∑ j ∈ Finset.range N,(q^j+q^(N-j)) :=
      Finset.sum_le_sum fun j hj => r.trappedBox_two_ended h hv (Finset.mem_range.mp hj).le
    _ = (∑ j ∈ Finset.range N,q^j)+(∑ j ∈ Finset.range N,q^(N-j)) := Finset.sum_add_distrib
    _ ≤ 1/(1-q)+1/(1-q) := add_le_add (geometric_partial_bound hq0 hq1 N) hb
    _ = _ := by ring

end StandardMapEntropy.NonlinearStable

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

lemma scalar_log_relative_error {b y e d : ℝ} (hb : 1≤|b|) (hy : y≠0)
    (hd0 : 0≤d) (hd1 : d≤1/2) (he : |e|≤d*|y|) :
    abs (Real.log |b*y+e|-Real.log |b|-Real.log |y|)≤2*d := by
  have hyp : 0 < |y| := abs_pos.mpr hy
  have hbp : 0 < |b| := lt_of_lt_of_le zero_lt_one hb
  have hsmall : |e|≤|y|/2 := he.trans (by
    nlinarith [mul_le_mul hd1 (le_refl |y|) hyp.le (hd0.trans hd1)])
  have hlower : |y|/2≤|b*y+e| := by
    have hh : |b*y|≤|b*y+e|+|e| := by
      simpa only [add_sub_cancel_right] using abs_sub (b*y+e) e
    rw [abs_mul] at hh
    have hb' := mul_le_mul_of_nonneg_right hb (abs_nonneg y)
    nlinarith
  have hD : 0<2/|y| := div_pos (by norm_num) hyp
  have hx : 1≤(2/|y|)*|b*y+e| := by
    have hc := mul_le_mul_of_nonneg_left hlower hD.le
    have heq : (2/|y|)*(|y|/2)=1 := by field_simp
    rwa [heq] at hc
  have hb' : 1≤(2/|y|)*|b*y| := by
    rw [abs_mul]
    have heq : (2/|y|)*(|b| *|y|)=2*|b| := by field_simp
    rw [heq]; linarith
  have hl := StandardMapEntropy.log_difference_of_lower hD hx hb'
  have hnorm : abs (|b*y+e|-|b*y|)≤|e| := by
    simpa only [add_sub_cancel_left] using abs_abs_sub_abs_le_abs_sub (b*y+e) (b*y)
  have hh := hl.trans (mul_le_mul_of_nonneg_left (hnorm.trans he) hD.le)
  rw [abs_mul,Real.log_mul hbp.ne' hyp.ne'] at hh
  have hright : (2/|y|)*(d*|y|)=2*d := by field_simp
  rw [hright] at hh
  convert hh using 1
  congr 1
  ring

theorem LocalRecurrence.linearized_log_distortion (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1)
    (hδ : (δ : ℝ)≤1/2) (D : ℕ → Plane →L[ℝ] Plane) (hD : ∀ n, ‖D n‖≤δ)
    {N : ℕ} {v : Plane} (hv : v∈r.extend.trappedBox N)
    (hsmall : ∀ j : ℕ,j<N → ‖D j‖≤(δ : ℝ)*‖r.extend.orbit v j‖) :
    abs (Real.log |((r.linearized D hD).orbit (0,1) N).2|-
      ∑ j ∈ Finset.range N,Real.log |r.b j|)≤4*(δ : ℝ)/(1-((ℓ+δ : ℝ≥0) : ℝ)) := by
  let R := r.linearized D hD
  let y := fun j : ℕ => |(R.orbit (0,1) j).2|
  have hcone : |(0 : ℝ)|≤|(1 : ℝ)| := by norm_num
  have hnz : (1 : ℝ)≠0 := one_ne_zero
  have hstep (j : ℕ) (hj : j<N) :
      abs ((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|)≤2*(δ : ℝ)*‖r.extend.orbit v j‖ := by
    have hy := R.orbit_snd_ne_zero h (v := (0,1)) hcone hnz j
    have hδj : (δ : ℝ)*‖r.extend.orbit v j‖≤1/2 :=
      ((mul_le_mul_of_nonneg_left (hv j hj.le) δ.coe_nonneg).trans_eq (mul_one _)).trans hδ
    have he : |(D j (R.orbit (0,1) j)).2|≤
        ((δ : ℝ)*‖r.extend.orbit v j‖)*|(R.orbit (0,1) j).2| := by
      have hh := (norm_snd_le (D j (R.orbit (0,1) j))).trans
        (((D j).le_opNorm _).trans (mul_le_mul_of_nonneg_right (hsmall j hj) (norm_nonneg _)))
      simpa only [Real.norm_eq_abs,R.orbit_norm_eq_snd h (v := (0,1)) hcone j] using hh
    have hb : 1≤|r.b j| := R.unstable_size_ge_one h j
    have hh := scalar_log_relative_error hb hy (mul_nonneg δ.coe_nonneg (norm_nonneg _)) hδj he
    change abs (Real.log |r.b j*(R.orbit (0,1) j).2+(D j (R.orbit (0,1) j)).2|-
      Real.log |(R.orbit (0,1) j).2|-Real.log |r.b j|)≤_
    convert hh using 1
    · congr 1; ring
    · ring
  have htel : (∑ j ∈ Finset.range N,((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|))=
      Real.log (y N)-(∑ j ∈ Finset.range N,Real.log |r.b j|) := by
    rw [Finset.sum_sub_distrib,Finset.sum_range_sub (fun j => Real.log (y j))]
    simp only [y,Recurrence.orbit,abs_one,Real.log_one,sub_zero]
  calc
    _ = abs (∑ j ∈ Finset.range N,((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|)) := congrArg abs htel.symm
    _ ≤ ∑ j ∈ Finset.range N,abs ((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|) := Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ j ∈ Finset.range N,2*(δ : ℝ)*‖r.extend.orbit v j‖ :=
      Finset.sum_le_sum fun j hj => hstep j (Finset.mem_range.mp hj)
    _ = (2*(δ : ℝ))*(∑ j ∈ Finset.range N,‖r.extend.orbit v j‖) := (Finset.mul_sum _ _ _).symm
    _ ≤ (2*(δ : ℝ))*(2/(1-((ℓ+δ : ℝ≥0) : ℝ))) :=
      mul_le_mul_of_nonneg_left (r.extend.trappedBox_sum_norm h hv) (by positivity)
    _ = _ := by ring

noncomputable def LocalRecurrence.trueOrbit (r : LocalRecurrence ℓ δ) (v : Plane) : ℕ → Plane
  | 0 => v
  | n+1 => r.step n (r.trueOrbit v n)

lemma LocalRecurrence.trueOrbit_eq_extend (r : LocalRecurrence ℓ δ) {v : Plane} {N : ℕ}
    (hv : v∈r.extend.trappedBox N) {n : ℕ} (hn : n≤N) : r.trueOrbit v n=r.extend.orbit v n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [LocalRecurrence.trueOrbit,ih (by omega),Recurrence.orbit,extend_step_eq _ n (hv n (by omega))]

lemma LocalRecurrence.trueOrbit_hasDerivAt (r : LocalRecurrence ℓ δ)
    (D : ℕ → Plane → Plane →L[ℝ] Plane)
    (hDeriv : ∀ j u, HasFDerivAt (r.remainder j) (D j u) u)
    (L : ℕ → Plane →L[ℝ] Plane) (hL : ∀ n, ‖L n‖≤δ)
    {v : Plane} {N : ℕ} (hmatch : ∀ j : ℕ,j<N → L j=D j (r.trueOrbit v j))
    {n : ℕ} (hn : n≤N) :
    HasDerivAt (fun t : ℝ => r.trueOrbit (v.1,t) n) ((r.linearized L hL).orbit (0,1) n) v.2 := by
  induction n with
  | zero => exact hasDerivAt_const _ _ |>.prodMk (hasDerivAt_id _)
  | succ n ih =>
    have hi := ih (by omega)
    have rem := (hDeriv n (r.trueOrbit v n)).comp_hasDerivAt v.2 hi
    have hrem : HasDerivAt (fun t : ℝ => r.remainder n (r.trueOrbit (v.1,t) n))
        (L n ((r.linearized L hL).orbit (0,1) n)) v.2 := by
      rw [hmatch n (by omega)]
      exact rem
    have hifst : HasDerivAt (fun t : ℝ => (r.trueOrbit (v.1,t) n).1)
        ((r.linearized L hL).orbit (0,1) n).1 v.2 := by
      exact hi.fst
    have hisnd : HasDerivAt (fun t : ℝ => (r.trueOrbit (v.1,t) n).2)
        ((r.linearized L hL).orbit (0,1) n).2 v.2 := by
      exact hi.snd
    have hrfst : HasDerivAt (fun t : ℝ => (r.remainder n (r.trueOrbit (v.1,t) n)).1)
        (L n ((r.linearized L hL).orbit (0,1) n)).1 v.2 := by
      exact hrem.fst
    have hrsnd : HasDerivAt (fun t : ℝ => (r.remainder n (r.trueOrbit (v.1,t) n)).2)
        (L n ((r.linearized L hL).orbit (0,1) n)).2 v.2 := by
      exact hrem.snd
    exact ((hifst.const_mul (r.a n)).add hrfst).prodMk
      ((hisnd.const_mul (r.b n)).add hrsnd)

end StandardMapEntropy.NonlinearStable

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

lemma continuous_injective_abs_sub_le {f : ℝ → ℝ} (hc : Continuous f)
    (hi : Function.Injective f) {s t u : ℝ} (hst : s≤t) (htu : t≤u) :
    |f t-f s|≤|f u-f s| := by
  rcases hc.strictMono_of_inj hi with hm | hm
  · rw [abs_of_nonneg (sub_nonneg.mpr (hm.monotone hst)),
      abs_of_nonneg (sub_nonneg.mpr (hm.monotone (hst.trans htu)))]
    exact sub_le_sub_right (hm.monotone htu) _
  · rw [abs_of_nonpos (sub_nonpos.mpr (hm.antitone hst)),
      abs_of_nonpos (sub_nonpos.mpr (hm.antitone (hst.trans htu)))]
    linarith [hm.antitone htu]

lemma Recurrence.transverse_injective (r : Recurrence ℓ δ) (h : ℓ+δ<1) (s : ℝ) (n : ℕ) :
    Function.Injective (fun t : ℝ => (r.orbit (s,t) n).2) := by
  intro t u he
  change (r.orbit (s,t) n).2=(r.orbit (s,u) n).2 at he
  have hh := (r.orbit_unstable_cone h s t u n).2
  rw [he,sub_self,abs_zero,mul_zero] at hh
  exact sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hh (abs_nonneg _)))

lemma Recurrence.transverse_between (r : Recurrence ℓ δ) (h : ℓ+δ<1)
    {s t u v : ℝ} (htu : t≤u) (huv : u≤v) (n : ℕ) :
    |(r.orbit (s,u) n).2-(r.orbit (s,t) n).2|≤
      |(r.orbit (s,v) n).2-(r.orbit (s,t) n).2| :=
  continuous_injective_abs_sub_le
    ((r.orbit_continuous n).comp (continuous_const.prodMk continuous_id)).snd
    (r.transverse_injective h s n) htu huv

theorem Recurrence.transverse_interval_trapped (r : Recurrence ℓ δ) (h : ℓ+δ<1)
    {s t u v : ℝ} (htu : t≤u) (huv : u≤v) {N : ℕ}
    (ht : ∀ n : ℕ,n≤N → ‖r.orbit (s,t) n‖≤1/3)
    (hv : ∀ n : ℕ,n≤N → ‖r.orbit (s,v) n‖≤1/3) :
    (s,u)∈r.trappedBox N := by
  intro n hn
  have hc := (r.orbit_unstable_cone h s u t n).1
  have hd := r.transverse_between h (s := s) htu huv n
  have ht' := norm_snd_le (r.orbit (s,t) n) |>.trans (ht n hn)
  have hv' := norm_snd_le (r.orbit (s,v) n) |>.trans (hv n hn)
  have hdiff : ‖r.orbit (s,u) n-r.orbit (s,t) n‖≤2/3 := by
    change max _ _ ≤ _
    simp only [Prod.fst_sub,Prod.snd_sub,Real.norm_eq_abs] at ht' hv' ⊢
    rw [max_eq_right hc]
    exact hd.trans ((abs_sub _ _).trans (by linarith))
  have hh := norm_add_le (r.orbit (s,u) n-r.orbit (s,t) n) (r.orbit (s,t) n)
  rw [sub_add_cancel] at hh
  linarith [ht n hn]

end StandardMapEntropy.NonlinearStable

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

lemma LocalRecurrence.trueOrbit_continuous (r : LocalRecurrence ℓ δ)
    (hc : ∀ j, Continuous (r.remainder j)) (n : ℕ) : Continuous (fun v => r.trueOrbit v n) := by
  induction n with
  | zero => exact continuous_id
  | succ n ih =>
    exact ((continuous_const.mul ih.fst).add ((hc n).comp ih).fst).prodMk
      ((continuous_const.mul ih.snd).add ((hc n).comp ih).snd)

lemma LocalRecurrence.trapped_transverse_derivative (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1)
    (hδ : (δ : ℝ)≤1/2) (D : ℕ → Plane → Plane →L[ℝ] Plane)
    (hd : ∀ n v, HasFDerivAt (r.remainder n) (D n v) v)
    (hsmall : ∀ n v, ‖v‖≤1 → ‖D n v‖≤(δ : ℝ)*‖v‖)
    {v : Plane} {N : ℕ} (hv : v∈r.extend.trappedBox N) :
    ∃ J : ℝ, HasDerivAt (fun t : ℝ => (r.trueOrbit (v.1,t) N).2) J v.2 ∧
      J≠0 ∧ |Real.log |J|-(∑ j ∈ Finset.range N,Real.log |r.b j|)|≤
        4*(δ : ℝ)/(1-((ℓ+δ : ℝ≥0) : ℝ)) := by
  classical
  let L (n : ℕ) : Plane →L[ℝ] Plane := if n<N then D n (r.trueOrbit v n) else 0
  have hLs (n : ℕ) (hn : n<N) : ‖L n‖≤(δ : ℝ)*‖r.extend.orbit v n‖ := by
    dsimp only [L]
    rw [ite_eq_left hn,r.trueOrbit_eq_extend hv hn.le]
    exact hsmall n _ (hv n hn.le)
  have hL (n : ℕ) : ‖L n‖≤δ := by
    by_cases hn : n<N
    · exact (hLs n hn).trans ((mul_le_mul_of_nonneg_left (hv n hn.le) δ.coe_nonneg).trans_eq (mul_one _))
    · simp only [L,ite_eq_right hn,norm_zero]; exact δ.coe_nonneg
  let R := r.linearized L hL
  refine ⟨(R.orbit (0,1) N).2,?_,R.orbit_snd_ne_zero h (by norm_num) one_ne_zero N,
    r.linearized_log_distortion h hδ L hL hv hLs⟩
  exact (r.trueOrbit_hasDerivAt D hd L hL (fun n hn => ite_eq_left hn) (le_refl N)).snd

lemma exp_bounds_of_log_error {J A C : ℝ} (hJ : J≠0) (h : |Real.log |J|-A|≤C) :
    Real.exp (A-C)≤|J| ∧ |J|≤Real.exp (A+C) := by
  have hh := abs_le.mp h
  have hpos := abs_pos.mpr hJ
  constructor
  · rw [←Real.exp_log hpos]
    exact Real.exp_le_exp.mpr (by linarith)
  · rw [←Real.exp_log hpos]
    exact Real.exp_le_exp.mpr (by linarith)

theorem LocalRecurrence.transverse_interval_distortion (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1)
    (hδ : (δ : ℝ)≤1/2) (D : ℕ → Plane → Plane →L[ℝ] Plane)
    (hd : ∀ n v, HasFDerivAt (r.remainder n) (D n v) v)
    (hsmall : ∀ n v, ‖v‖≤1 → ‖D n v‖≤(δ : ℝ)*‖v‖)
    {s t u : ℝ} (htu : t≤u) {N : ℕ}
    (ht : ∀ n : ℕ,n≤N → ‖r.extend.orbit (s,t) n‖≤1/3)
    (hu : ∀ n : ℕ,n≤N → ‖r.extend.orbit (s,u) n‖≤1/3) :
    let A := ∑ j ∈ Finset.range N,Real.log |r.b j|
    let C := 4*(δ : ℝ)/(1-((ℓ+δ : ℝ≥0) : ℝ))
    Real.exp (A-C)*(u-t)≤|(r.trueOrbit (s,u) N).2-(r.trueOrbit (s,t) N).2| ∧
      |(r.trueOrbit (s,u) N).2-(r.trueOrbit (s,t) N).2|≤Real.exp (A+C)*(u-t) := by
  dsimp only
  rcases htu.eq_or_lt with he | htu
  · subst u; simp
  let f : ℝ → ℝ := fun v => (r.trueOrbit (s,v) N).2
  have hfc : Continuous f := ((r.trueOrbit_continuous (fun n => continuous_iff_continuousAt.mpr
    fun v => (hd n v).continuousAt) N).comp (continuous_const.prodMk continuous_id)).snd
  have htrap (v : ℝ) (hv : v∈Icc t u) : (s,v)∈r.extend.trappedBox N :=
    r.extend.transverse_interval_trapped h hv.1 hv.2 ht hu
  have hf (v : ℝ) (hv : v∈Icc t u) : ∃ J : ℝ, HasDerivAt f J v ∧ J≠0 ∧
      |Real.log |J|-(∑ j ∈ Finset.range N,Real.log |r.b j|)|≤
        4*(δ : ℝ)/(1-((ℓ+δ : ℝ≥0) : ℝ)) :=
    r.trapped_transverse_derivative h hδ D hd hsmall (htrap v hv)
  obtain ⟨c,hc,he⟩ := exists_deriv_eq_slope f htu hfc.continuousOn
    (fun v hv => (hf v ⟨hv.1.le,hv.2.le⟩).choose_spec.1.differentiableAt.differentiableWithinAt)
  obtain ⟨J,hJ,hJn,hJL⟩ := hf c ⟨hc.1.le,hc.2.le⟩
  rw [hJ.deriv] at he
  have hab : f u-f t=J*(u-t) := (eq_div_iff (sub_ne_zero.mpr htu.ne')).mp he |>.symm
  have heq : |f u-f t|=|J| *(u-t) := by rw [hab,abs_mul,abs_of_pos (sub_pos.mpr htu)]
  change _≤|f u-f t| ∧ |f u-f t|≤_
  rw [heq]
  have hb := exp_bounds_of_log_error hJn hJL
  exact ⟨mul_le_mul_of_nonneg_right hb.1 (sub_nonneg.mpr htu.le),
    mul_le_mul_of_nonneg_right hb.2 (sub_nonneg.mpr htu.le)⟩

end StandardMapEntropy.NonlinearStable

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

lemma Recurrence.orbit_pair_cone (r : Recurrence ℓ δ) (h : ℓ+δ<1) {v w : Plane}
    (hv : |v.1-w.1|≤|v.2-w.2|) (n : ℕ) :
    |(r.orbit v n).1-(r.orbit w n).1|≤|(r.orbit v n).2-(r.orbit w n).2| ∧
    |v.2-w.2|≤((ℓ+δ : ℝ≥0) : ℝ)^n*|(r.orbit v n).2-(r.orbit w n).2| := by
  induction n with
  | zero => exact ⟨hv,by simp only [Recurrence.orbit,pow_zero,one_mul,le_refl]⟩
  | succ n ih =>
    have hh := r.unstable_cone_step h n (r.orbit v n) (r.orbit w n) ih.1
    refine ⟨hh.1,ih.2.trans ?_⟩
    exact (mul_le_mul_of_nonneg_left hh.2 (pow_nonneg (ℓ+δ).coe_nonneg n)).trans_eq
      (by simp only [Recurrence.orbit,pow_succ]; ring)
lemma affine_cone {V : Plane} (hV : |V.1|≤|V.2|) (p : Plane) (t u : ℝ) :
    |(p+t•V).1-(p+u•V).1|≤|(p+t•V).2-(p+u•V).2| := by
  have he : p+t•V-(p+u•V)=(t-u)•V := by rw [add_sub_add_left_eq_sub,sub_smul]
  change |(p+t•V-(p+u•V)).1|≤|(p+t•V-(p+u•V)).2|
  rw [he]
  change |(t-u)*V.1|≤|(t-u)*V.2|
  rw [abs_mul,abs_mul]
  exact mul_le_mul_of_nonneg_left hV (abs_nonneg _)

lemma Recurrence.affine_transverse_injective (r : Recurrence ℓ δ) (h : ℓ+δ<1)
    {V : Plane} (hV : |V.1|≤|V.2|) (hV0 : V.2≠0) (p : Plane) (n : ℕ) :
    Function.Injective (fun t : ℝ => (r.orbit (p+t•V) n).2) := by
  intro t u he
  change (r.orbit (p+t•V) n).2=(r.orbit (p+u•V) n).2 at he
  have hh := (r.orbit_pair_cone h (affine_cone hV p t u) n).2
  rw [he,sub_self,abs_zero,mul_zero] at hh
  have hz := sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hh (abs_nonneg _)))
  simp only [Prod.snd_add] at hz
  exact (mul_left_inj' hV0).mp (add_left_cancel hz)

lemma Recurrence.affine_interval_trapped (r : Recurrence ℓ δ) (h : ℓ+δ<1)
    {V : Plane} (hV : |V.1|≤|V.2|) (hV0 : V.2≠0) (p : Plane)
    {t u v : ℝ} (htu : t≤u) (huv : u≤v) {N : ℕ}
    (ht : ∀ n : ℕ,n≤N → ‖r.orbit (p+t•V) n‖≤1/3)
    (hv : ∀ n : ℕ,n≤N → ‖r.orbit (p+v•V) n‖≤1/3) :
    p+u•V∈r.trappedBox N := by
  intro n hn
  have hc := (r.orbit_pair_cone h (affine_cone hV p u t) n).1
  have hd := continuous_injective_abs_sub_le
    ((r.orbit_continuous n).comp (continuous_const.add (continuous_id.smul continuous_const))).snd
    (r.affine_transverse_injective h hV hV0 p n) htu huv
  change |(r.orbit (p+u•V) n).2-(r.orbit (p+t•V) n).2|≤
    |(r.orbit (p+v•V) n).2-(r.orbit (p+t•V) n).2| at hd
  have ht' := norm_snd_le (r.orbit (p+t•V) n) |>.trans (ht n hn)
  have hv' := norm_snd_le (r.orbit (p+v•V) n) |>.trans (hv n hn)
  have hdiff : ‖r.orbit (p+u•V) n-r.orbit (p+t•V) n‖≤2/3 := by
    change max _ _ ≤ _
    simp only [Prod.fst_sub,Prod.snd_sub,Real.norm_eq_abs] at ht' hv' ⊢
    rw [max_eq_right hc]
    exact hd.trans ((abs_sub _ _).trans (by linarith))
  have hh := norm_add_le (r.orbit (p+u•V) n-r.orbit (p+t•V) n) (r.orbit (p+t•V) n)
  rw [sub_add_cancel] at hh
  linarith [ht n hn]

theorem LocalRecurrence.linearized_cone_log_distortion (r : LocalRecurrence ℓ δ) (h : ℓ+δ<1)
    (hδ : (δ : ℝ)≤1/2) (D : ℕ → Plane →L[ℝ] Plane) (hD : ∀ n, ‖D n‖≤δ)
    {N : ℕ} {v : Plane} (hv : v∈r.extend.trappedBox N)
    {V : Plane} (hcone : |V.1|≤|V.2|) (hnz : V.2≠0)
    (hsmall : ∀ j : ℕ,j<N → ‖D j‖≤(δ : ℝ)*‖r.extend.orbit v j‖) :
    abs (Real.log |((r.linearized D hD).orbit V N).2|-Real.log |V.2|-
      ∑ j ∈ Finset.range N,Real.log |r.b j|)≤4*(δ : ℝ)/(1-((ℓ+δ : ℝ≥0) : ℝ)) := by
  let R := r.linearized D hD
  let y := fun j : ℕ => |(R.orbit V j).2|
  have hstep (j : ℕ) (hj : j<N) :
      abs ((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|)≤2*(δ : ℝ)*‖r.extend.orbit v j‖ := by
    have hy := R.orbit_snd_ne_zero h (v := V) hcone hnz j
    have hδj : (δ : ℝ)*‖r.extend.orbit v j‖≤1/2 :=
      ((mul_le_mul_of_nonneg_left (hv j hj.le) δ.coe_nonneg).trans_eq (mul_one _)).trans hδ
    have he : |(D j (R.orbit V j)).2|≤
        ((δ : ℝ)*‖r.extend.orbit v j‖)*|(R.orbit V j).2| := by
      have hh := (norm_snd_le (D j (R.orbit V j))).trans
        (((D j).le_opNorm _).trans (mul_le_mul_of_nonneg_right (hsmall j hj) (norm_nonneg _)))
      simpa only [Real.norm_eq_abs,R.orbit_norm_eq_snd h (v := V) hcone j] using hh
    have hb : 1≤|r.b j| := R.unstable_size_ge_one h j
    have hh := scalar_log_relative_error hb hy (mul_nonneg δ.coe_nonneg (norm_nonneg _)) hδj he
    change abs (Real.log |r.b j*(R.orbit V j).2+(D j (R.orbit V j)).2|-
      Real.log |(R.orbit V j).2|-Real.log |r.b j|)≤_
    convert hh using 1
    · congr 1; ring
    · ring
  have htel : (∑ j ∈ Finset.range N,((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|))=
      Real.log (y N)-Real.log |V.2|-(∑ j ∈ Finset.range N,Real.log |r.b j|) := by
    rw [Finset.sum_sub_distrib,Finset.sum_range_sub (fun j => Real.log (y j))]
    rfl
  calc
    _ = abs (∑ j ∈ Finset.range N,((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|)) := congrArg abs htel.symm
    _ ≤ ∑ j ∈ Finset.range N,abs ((Real.log (y (j+1))-Real.log (y j))-Real.log |r.b j|) := Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ j ∈ Finset.range N,2*(δ : ℝ)*‖r.extend.orbit v j‖ :=
      Finset.sum_le_sum fun j hj => hstep j (Finset.mem_range.mp hj)
    _ = (2*(δ : ℝ))*(∑ j ∈ Finset.range N,‖r.extend.orbit v j‖) := (Finset.mul_sum _ _ _).symm
    _ ≤ (2*(δ : ℝ))*(2/(1-((ℓ+δ : ℝ≥0) : ℝ))) :=
      mul_le_mul_of_nonneg_left (r.extend.trappedBox_sum_norm h hv) (by positivity)
    _ = _ := by ring

lemma LocalRecurrence.trueOrbit_affine_hasDerivAt (r : LocalRecurrence ℓ δ)
    (D : ℕ → Plane → Plane →L[ℝ] Plane)
    (hDeriv : ∀ j u, HasFDerivAt (r.remainder j) (D j u) u)
    (L : ℕ → Plane →L[ℝ] Plane) (hL : ∀ n, ‖L n‖≤δ)
    (p V : Plane) (x : ℝ) {N : ℕ} (hmatch : ∀ j : ℕ,j<N → L j=D j (r.trueOrbit (p+x•V) j))
    {n : ℕ} (hn : n≤N) :
    HasDerivAt (fun t : ℝ => r.trueOrbit (p+t•V) n) ((r.linearized L hL).orbit V n) x := by
  induction n with
  | zero =>
    have h1 : HasDerivAt (fun t : ℝ => p.1+t*V.1) V.1 x := by
      convert ((hasDerivAt_id x).mul_const V.1).const_add p.1 using 1 <;> first | rfl | simp only [one_mul]
    have h2 : HasDerivAt (fun t : ℝ => p.2+t*V.2) V.2 x := by
      convert ((hasDerivAt_id x).mul_const V.2).const_add p.2 using 1 <;> first | rfl | simp only [one_mul]
    exact h1.prodMk h2
  | succ n ih =>
    have hi := ih (by omega)
    have rem := (hDeriv n (r.trueOrbit (p+x•V) n)).comp_hasDerivAt x hi
    have hrem : HasDerivAt (fun t : ℝ => r.remainder n (r.trueOrbit (p+t•V) n))
        (L n ((r.linearized L hL).orbit V n)) x := by
      rw [hmatch n (by omega)]
      exact rem
    have hifst : HasDerivAt (fun t : ℝ => (r.trueOrbit (p+t•V) n).1)
        ((r.linearized L hL).orbit V n).1 x := by
      exact hi.fst
    have hisnd : HasDerivAt (fun t : ℝ => (r.trueOrbit (p+t•V) n).2)
        ((r.linearized L hL).orbit V n).2 x := by
      exact hi.snd
    have hrfst : HasDerivAt (fun t : ℝ => (r.remainder n (r.trueOrbit (p+t•V) n)).1)
        (L n ((r.linearized L hL).orbit V n)).1 x := by
      exact hrem.fst
    have hrsnd : HasDerivAt (fun t : ℝ => (r.remainder n (r.trueOrbit (p+t•V) n)).2)
        (L n ((r.linearized L hL).orbit V n)).2 x := by
      exact hrem.snd
    exact ((hifst.const_mul (r.a n)).add hrfst).prodMk
      ((hisnd.const_mul (r.b n)).add hrsnd)

end StandardMapEntropy.NonlinearStable

end
end

end OAI