lean/OAI/Analysis/BiholderTransport/Regularity/Alignment.lean

import Mathlib
import OAI.Analysis.BiholderTransport.Coordinates.PoleCoordinates
import OAI.Analysis.BiholderTransport.Regularity.HopfApproximation

namespace OAI

noncomputable section
open Set Filter Manifold Bundle
open scoped Topology ContDiff

namespace WeakMTWTransport
variable {n : ℕ} {M : Type*} [MetricSpace M] [CompactSpace M] [Nonempty M]
  [ChartedSpace (Model n) M] [IsManifold 𝓘(ℝ,Model n) ∞ M]
  [RiemannianBundle (fun x : M => TangentSpace 𝓘(ℝ,Model n) x)]
  [IsContMDiffRiemannianBundle 𝓘(ℝ,Model n) ∞ (Model n)
    (fun x : M => TangentSpace 𝓘(ℝ,Model n) x)]
  [IsRiemannianManifold 𝓘(ℝ,Model n) M]
lemma hopfLax_derivative_of_scaled_minimizer {u : M → ℝ} (hu : Continuous u)
    {x : M} {p : TangentSpace 𝓘(ℝ,Model n) x}
    {t : ℝ} (ht : 0<t) (hp : t • p∈minimizingVectors x)
    (heq : hopfLax t u (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1 =
      u x+cost x (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1/t)
    (hd : MDifferentiableAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) (hopfLax t u)
      (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1) :
    HasMFDerivAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) (hopfLax t u)
      (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1
      (innerSL ℝ (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).2) := by
  let w : TangentBundle 𝓘(ℝ,Model n) M := ⟨x,p⟩
  let z := sprayFlow t w
  obtain ⟨ε,hε,hεt,_,_,Hε⟩ := exists_two_short_legs x p ht
    (show t<t+1 by linarith) zero_lt_one
  have hshort := (Filter.Eventually.self_of_nhds Hε).2.2.2
  let a := (sprayFlow (t-ε) w).1
  let G : M → ℝ := fun y => u x+cost x a/(t-ε)+cost a y/ε
  have hG : HasMFDerivAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) G z.1 (innerSL ℝ z.2) := by
    have H := (hasMFDerivAt_const (I := 𝓘(ℝ,Model n)) (I' := 𝓘(ℝ,ℝ))
      (u x+cost x a/(t-ε)) z.1).add (hshort.const_smul ε⁻¹)
    have heD : 0+ε⁻¹ • innerSL ℝ (ε • (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).2) =
        innerSL ℝ z.2 := by
      ext v
      simp only [zero_add,_root_.smul_apply,smul_eq_mul,innerSL_apply_apply,
        real_inner_smul_left]
      dsimp [z,w]
      field_simp
    replace H := H.congr_mfderiv heD
    have heG : G = ((fun _ => u x+cost x a/(t-ε)) +
        ε⁻¹ • fun y => dist (sprayFlow (t-ε) (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1 y^2/2) := by
      funext y
      dsimp [G,cost,a,w]
      ring
    rw [heG]
    exact H
  have hmin : dist x z.1=t*‖p‖ := by
    dsimp [z,w]
    rw [←riemannianExp_smul,hp,norm_smul,
      Real.norm_eq_abs,abs_of_pos ht]
  have hleft : dist x a=(t-ε)*‖p‖ :=
    sprayFlow_minimizing_prefix w (sub_pos.mpr hεt).le (by linarith) hmin
  have hright : dist a z.1=ε*‖p‖ := by
    have H := sprayFlow_minimizing_subinterval w (sub_pos.mpr hεt).le (by linarith) hmin
    simpa only [sub_sub_cancel] using H
  have hcontact : hopfLax t u z.1=G z.1 := by
    rw [heq]
    dsimp [G,cost]
    rw [hmin,hleft,hright]
    field_simp
    ring
  have hle : ∀ y, hopfLax t u y≤G y := by
    intro y
    have H := cost_divided_triangle_two_times x a y (sub_pos.mpr hεt) hε
    rw [sub_add_cancel] at H
    exact (hopfLax_le hu t y x).trans (by dsimp [G]; linarith)
  exact hd.hasMFDerivAt.congr_mfderiv
    ((upper_contact_mfderiv hd hG.mdifferentiableAt (Filter.Eventually.of_forall hle) hcontact).trans hG.mfderiv)

lemma hopfLax_backward_minimizer {u : M → ℝ} (hu : Continuous u)
    {t : ℝ} (ht : 0<t) {x z : M}
    (hval : hopfLax t u z=u x+cost x z/t)
    (hd : MDifferentiableAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) (hopfLax t u) z) :
    (sprayFlow (-t) (⟨z,riemannianGradient (hopfLax t u) z⟩ :
      TangentBundle 𝓘(ℝ,Model n) M)).1=x := by
  obtain ⟨p,hp,hpz⟩ := exists_minimizing_vector (n := n) x z
  let q := t⁻¹ • p
  have hq : t • q∈minimizingVectors x := by
    simpa only [q,smul_smul,mul_inv_cancel₀ ht.ne',one_smul] using hp
  have hz : (sprayFlow t (⟨x,q⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1=z := by
    rw [←riemannianExp_smul]
    simpa only [q,smul_smul,mul_inv_cancel₀ ht.ne',one_smul] using hpz
  have H := hopfLax_derivative_of_scaled_minimizer hu ht hq (hz ▸ hval) (hz ▸ hd)
  have HG := riemannianGradient_eq_of_derivative H
  have HB : (⟨z,riemannianGradient (hopfLax t u) z⟩ : TangentBundle 𝓘(ℝ,Model n) M)=
      sprayFlow t (⟨x,q⟩ : TangentBundle 𝓘(ℝ,Model n) M) := by
    rw [←hz,HG]
  rw [HB,←sprayFlow_add,neg_add_cancel,sprayFlow_zero]

omit [CompactSpace M] [Nonempty M]
  [IsContMDiffRiemannianBundle 𝓘(ℝ,Model n) ∞ (Model n)
    (fun x : M => TangentSpace 𝓘(ℝ,Model n) x)]
  [IsRiemannianManifold 𝓘(ℝ,Model n) M] in
lemma gradients_cancel_at_local_max {f g : M → ℝ} {z : M}
    (hf : MDifferentiableAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) f z)
    (hg : MDifferentiableAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) g z)
    (hmax : ∀ᶠ a in 𝓝 z,f a+g a≤f z+g z) :
    riemannianGradient g z= -riemannianGradient (n := n) f z := by
  let : FiniteDimensional ℝ (TangentSpace 𝓘(ℝ,Model n) z) :=
    inferInstanceAs (FiniteDimensional ℝ (Model n))
  have H := upper_contact_mfderiv (hf.add hg)
    (mdifferentiableAt_const (I := 𝓘(ℝ,Model n)) (I' := 𝓘(ℝ,ℝ))) hmax rfl
  rw [(hasMFDerivAt_riemannianGradient hf).add
    (hasMFDerivAt_riemannianGradient hg) |>.mfderiv,
    (hasMFDerivAt_const (I := 𝓘(ℝ,Model n)) (I' := 𝓘(ℝ,ℝ)) (f z+g z) z).mfderiv] at H
  have HE : riemannianGradient (n := n) f z+riemannianGradient (n := n) g z=0 := by
    apply ext_inner_right ℝ
    intro u
    have H0 := congrArg (fun L => L u) H
    change inner ℝ (riemannianGradient f z) u+inner ℝ (riemannianGradient g z) u=0 at H0
    simpa only [inner_add_left,inner_zero_left] using H0
  exact eq_neg_of_add_eq_zero_left (by simpa only [add_comm] using HE)

lemma WeakMTW.hopf_maximum_aligned (hmtw : WeakMTW (n := n) (M := M))
    {w v : M → ℝ} (hw : Continuous w) (hv : Continuous v)
    {t : ℝ} (ht : 0<t) (ht1 : t<1) {x y z : M}
    (hx : hopfLax t (cTransform w) z=cTransform w x+cost x z/t)
    (hy : hopfLax (1-t) v z=v y+cost y z/(1-t))
    (hdy : MDifferentiableAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) (hopfLax (1-t) v) z)
    (hmax : ∀ᶠ a in 𝓝 z,hopfLax t (cTransform w) a+hopfLax (1-t) v a≤
      hopfLax t (cTransform w) z+hopfLax (1-t) v z) :
    ∃ p : TangentSpace 𝓘(ℝ,Model n) x,
      p∈normalSubdifferential (cTransform w) x ∧ p∈minimizingVectors x ∧
      z=riemannianExp x (t • p) ∧ y=riemannianExp x p ∧
      hopfLax t (cTransform w) z+hopfLax (1-t) v z=v y-cTransform (cTransform w) y := by
  let g := cTransform w
  have hg : Continuous g := continuous_cTransform hw
  obtain ⟨q,hq,hqz⟩ := exists_minimizing_vector (n := n) x z
  let p := t⁻¹ • q
  have hps : p∈normalSubdifferential g x := by
    apply global_min_divided_cost_subgradient hq ht
    intro a
    rw [hqz,←hx]
    exact hopfLax_le hg t z a
  obtain ⟨hp,hfull⟩ := hmtw.global_support hw hps
  have hpz : riemannianExp x (t • p)=z := by
    simpa only [p,smul_smul,mul_inv_cancel₀ ht.ne',one_smul] using hqz
  have hPz : (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1=z := by
    rwa [←riemannianExp_smul]
  have hdg := hmtw.mdifferentiable_hopfLax hg (continuous_cTransform hg)
    (show IsCostDualPair g (cTransform g) from ⟨(cTransform_triple hw).symm,rfl⟩) ht ht1 z
  have hneg := gradients_cancel_at_local_max hdg hdy hmax
  have hder := hopfLax_derivative_of_minimizer hg hp ht ht1.le (hPz ▸ hx) (hPz ▸ hdg)
  have HG := riemannianGradient_eq_of_derivative hder
  have HU : (⟨z,riemannianGradient (hopfLax t g) z⟩ : TangentBundle 𝓘(ℝ,Model n) M)=
      sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M) := by
    rw [←hPz,HG]
  have HV : (⟨z,riemannianGradient (hopfLax (1-t) v) z⟩ : TangentBundle 𝓘(ℝ,Model n) M)=
      tangentScale (-1) (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)) := by
    rw [←HU]
    simp only [tangentScale,neg_one_smul,hneg]
  have hback := hopfLax_backward_minimizer hv (sub_pos.mpr ht1) hy hdy
  rw [HV,sprayFlow_scale] at hback
  change (sprayFlow ((-1)*(-(1-t))) (sprayFlow t
    (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M))).1=y at hback
  rw [←sprayFlow_add,show (-1)*(-(1-t))+t=1 by ring,←riemannianExp_eq_sprayFlow] at hback
  have hpy : y=riemannianExp x p := hback.symm
  refine ⟨p,hps,hp,hpz.symm,hpy,?_⟩
  have hright : dist z y=(1-t)*‖p‖ := by
    rw [←hpz,hpy,riemannianExp_smul,riemannianExp_eq_sprayFlow]
    exact sprayFlow_minimizing_subinterval (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)
      ht.le ht1.le (by rw [one_mul,←riemannianExp_eq_sprayFlow]; exact hp)
  have hcost : cost y z/(1-t)=(1-t)*‖p‖^2/2 := by
    rw [cost,dist_comm,hright]
    field_simp
  have hsum := minimizing_split_contact hp ht ht1
  rw [hpz,←hpy] at hsum
  have hval1 : -cTransform g y=g x+cost x y := by
    have H := hopfLax_eq_of_min hg 1 y x (by simpa only [hpy,div_one] using hfull)
    simpa only [hopfLax_one _ hg,div_one] using H
  rw [hx,hy,hcost]
  change g x+cost x z/t+(v y+(1-t)*‖p‖^2/2)=v y-cTransform g y
  linarith only [hsum,hval1]

end WeakMTWTransport
end

end OAI