import Mathlib
import OAI.Analysis.BiholderTransport.Regularity.MetricDefinitions
import OAI.Analysis.BiholderTransport.CostGeometry.SplitStationary

namespace OAI

section
section
noncomputable section
open Set Filter Manifold Bundle ContinuousLinearMap
open scoped Topology ContDiff

namespace WeakMTWTransport
section SplitEndpoint
variable {n : ℕ} {M : Type*} [MetricSpace M] [CompactSpace 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 diagonalSplitAction_endpoint_gradient {x : M}
    {p v : TangentSpace 𝓘(ℝ,Model n) x} {t : ℝ}
    {r : TangentSpace 𝓘(ℝ,Model n) (riemannianExp x p)}
    (hr : r∈injectivityDomain (riemannianExp x p))
    (heq : riemannianExp (riemannianExp x p) r=riemannianExp x (t • v))
    (hF : DifferentiableAt ℝ (diagonalSplitAction x t) (p,v))
    (k : TangentSpace 𝓘(ℝ,Model n) x) :
    fderiv ℝ (diagonalSplitAction x t) (p,v) (k,0)=
      -inner ℝ r (mfderiv 𝓘(ℝ,TangentSpace 𝓘(ℝ,Model n) x) 𝓘(ℝ,Model n)
        (riemannianExp x) p k)/(1-t) := by
  let X := TangentSpace 𝓘(ℝ,Model n) x
  let y := riemannianExp x p
  have hc := cost_start_gradient_of_injectivityDomain hr
  rw [heq] at hc
  have hc' : HasMFDerivAt 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ)
      (fun z => cost (riemannianExp x (t • v)) z) y (innerSL ℝ (-r)) := by
    have hswap : (fun z => cost (riemannianExp x (t • v)) z)=
        (fun z => cost z (riemannianExp x (t • v))) := funext (fun z => cost_symm _ _)
    rw [hswap]
    exact hc
  have hE := (contMDiff_riemannianExp_fiber x p).mdifferentiableAt (by simp)
  have hD := hc'.comp p hE.hasMFDerivAt
  have hD' : HasFDerivAt (fun w : X => cost (riemannianExp x (t • v)) (riemannianExp x w))
      ((innerSL ℝ (-r)).comp (mfderiv 𝓘(ℝ,X) 𝓘(ℝ,Model n) (riemannianExp x) p)) p := by
    convert! hD.hasFDerivAt using 1
  have hpart := (hD'.mul_const (1-t)⁻¹).const_add
    (cost x (riemannianExp x (t • v))/t)
  have heqfun : (fun w : X => diagonalSplitAction x t (w,v)) =
      (fun w : X => cost x (riemannianExp x (t • v))/t +
        cost (riemannianExp x (t • v)) (riemannianExp x w)*(1-t)⁻¹) := by
    funext w
    simp only [diagonalSplitAction,splitNormalAction,riemannianExp_zero,div_eq_mul_inv]
  rw [←heqfun] at hpart
  have hl := (hasFDerivAt_id (𝕜 := ℝ) p).prodMk (hasFDerivAt_const v p)
  have hfull := hF.hasFDerivAt.comp (f := fun w : X => (w,v)) p hl
  have H := congrArg (fun A : X →L[ℝ] ℝ => A k) (hfull.unique hpart)
  change fderiv ℝ (diagonalSplitAction x t) (p,v) (k,0)=
    (1-t)⁻¹ * inner ℝ (-r) (mfderiv 𝓘(ℝ,X) 𝓘(ℝ,Model n) (riemannianExp x) p k) at H
  rw [H,inner_neg_left,div_eq_mul_inv,mul_comm]

lemma diagonalSplitAction_mixed_endpoint {x : M}
    {p : TangentSpace 𝓘(ℝ,Model n) x} {t : ℝ}
    (hleft : t • p∈injectivityDomain x)
    (hright : (1-t) • (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).2∈
      injectivityDomain (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1)
    {q : TangentSpace 𝓘(ℝ,Model n) x → TangentSpace 𝓘(ℝ,Model n) (riemannianExp x p)}
    (hq : DifferentiableAt ℝ q p)
    (hqI : ∀ᶠ v in 𝓝 p, q v∈injectivityDomain (riemannianExp x p))
    (hqr : ∀ᶠ v in 𝓝 p, riemannianExp (riemannianExp x p) (q v)=riemannianExp x (t • v))
    (a k : TangentSpace 𝓘(ℝ,Model n) x) :
    fderiv ℝ (fderiv ℝ (diagonalSplitAction x t)) (p,p) (0,a) (k,0)=
      -inner ℝ (fderiv ℝ q p a) (mfderiv 𝓘(ℝ,TangentSpace 𝓘(ℝ,Model n) x) 𝓘(ℝ,Model n)
        (riemannianExp x) p k)/(1-t) := by
  let X := TangentSpace 𝓘(ℝ,Model n) x
  let F := diagonalSplitAction (n := n) x t
  let E := mfderiv 𝓘(ℝ,X) 𝓘(ℝ,Model n) (riemannianExp x) p
  have hF : ContDiffAt ℝ 2 F (p,p) := (diagonalSplitAction_contDiffAt hleft hright).of_le
    (ENat.natCast_le_of_coe_top_le_withTop le_rfl 2)
  have hdf := (hF.fderiv_right (m := 1) (by norm_num)).differentiableAt (by norm_num)
  have hl := (hasFDerivAt_const p p).prodMk (hasFDerivAt_id (𝕜 := ℝ) p)
  have hD := ((hdf.hasFDerivAt.comp (f := fun v : X => (p,v)) p hl).clm_apply
    (hasFDerivAt_const (k,(0:X)) p)).fderiv
  have hnF : ∀ᶠ v : X in 𝓝 p, DifferentiableAt ℝ F (p,v) :=
    (hl.continuousAt.eventually ((hF.of_le (m := 1) (by norm_num)).eventually (by norm_num))).mono
      (fun _ h => h.differentiableAt (by norm_num))
  have heq : (fun v : X => fderiv ℝ F (p,v) (k,0)) =ᶠ[𝓝 p]
      (fun v => -inner ℝ (E k) (q v)*(1-t)⁻¹) := by
    filter_upwards [hnF,hqI,hqr] with v hv hvI hvr
    rw [diagonalSplitAction_endpoint_gradient hvI hvr hv,real_inner_comm,div_eq_mul_inv]
  have hi := (((innerSL ℝ (E k)).hasFDerivAt.comp p hq.hasFDerivAt).neg.mul_const (1-t)⁻¹).fderiv
  have H := congrArg (fun A : X →L[ℝ] ℝ => A a) (hD.symm.trans (heq.fderiv_eq.trans hi))
  simp only [_root_.add_apply,ContinuousLinearMap.comp_apply,_root_.zero_apply,
    map_zero,zero_add,ContinuousLinearMap.flip_apply,ContinuousLinearMap.prod_apply,
    _root_.smul_apply,smul_eq_mul,_root_.neg_apply] at H
  change fderiv ℝ (fderiv ℝ F) (p,p) (0,a) (k,0)=
    (1-t)⁻¹ * (-inner ℝ (E k) (fderiv ℝ q p a)) at H
  rw [H,real_inner_comm,div_eq_mul_inv,mul_comm]

end SplitEndpoint
end WeakMTWTransport

end

end

end

end OAI