lean/OAI/Analysis/BiholderTransport/Volume/DiagonalKernel.lean

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

namespace OAI

noncomputable section

namespace WeakMTWTransport

open Set MeasureTheory Manifold Bundle
open scoped ContDiff Manifold ENNReal NNReal Topology

open Set Filter
open scoped Topology NNReal

open Set Filter
open scoped Topology

open Set Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set
open scoped Topology

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

open Set Filter ContinuousLinearMap InnerProductSpace
open scoped Topology ContDiff

open Set Filter ContinuousLinearMap
open scoped Topology ContDiff

open Set Filter ContinuousLinearMap
open scoped Topology ContDiff

open Set Filter ContinuousLinearMap
open scoped Topology ContDiff
open scoped NNReal

open Set Filter ContinuousLinearMap
open scoped Topology ContDiff

open Set Filter ContinuousLinearMap
open scoped Topology
open MeasureTheory
open scoped ContDiff ENNReal

open Set Filter Manifold Bundle ContinuousLinearMap MeasureTheory
open scoped Topology ContDiff Manifold Bundle ENNReal

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology Manifold

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

open Set Filter Manifold Bundle
open scoped Topology ContDiff Manifold Bundle

open Set Filter Manifold Bundle
open scoped Topology ContDiff Manifold Bundle

open Set Filter Bundle
open scoped Topology Bundle

open scoped Topology
open Function Manifold Set
open Manifold Bundle
open scoped Manifold Bundle
open Set

open Set Filter
open scoped Topology ContDiff

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter
open scoped ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter
open scoped ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter
open scoped ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set Filter
open scoped ContDiff Topology

section
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma diagonal_stationary_hessian_null {F : E×E → ℝ} {p k : E}
    (hF : ContDiffAt ℝ 2 F (p,p))
    (hstat : ∀ᶠ v in 𝓝 p, fderiv ℝ F (v,v) (0,k)=0)
    (hker : ∀ᶠ v in 𝓝 p, fderiv ℝ F (p,v) (k,0)=0) :
    fderiv ℝ (fderiv ℝ F) (p,p) (0,k) (0,k)=0 := by
  have hdf := (hF.fderiv_right (m := 1) (by norm_num)).differentiableAt (by norm_num)
  let L : E →L[ℝ] E×E := (ContinuousLinearMap.id ℝ E).prod (ContinuousLinearMap.id ℝ E)
  have hD₁ := ((hdf.hasFDerivAt.comp (f := fun v : E => (v,v)) p L.hasFDerivAt).clm_apply
    (hasFDerivAt_const ((0:E),k) p)).fderiv
  have hz₁ : fderiv ℝ (fun v : E => fderiv ℝ F (v,v) (0,k)) p=0 := by
    have heq : (fun v : E => fderiv ℝ F (v,v) (0,k)) =ᶠ[𝓝 p] (fun _ => (0:ℝ)) := hstat
    rw [heq.fderiv_eq]
    exact (hasFDerivAt_const (0:ℝ) p).fderiv
  have hd₁ := congrArg (fun A : E →L[ℝ] ℝ => A k) (hD₁.symm.trans hz₁)
  simp only [add_apply,ContinuousLinearMap.comp_apply,
    zero_apply,map_zero,zero_add,ContinuousLinearMap.flip_apply,L,
    ContinuousLinearMap.prod_apply,ContinuousLinearMap.id_apply] at hd₁
  have hL₂ : HasFDerivAt (fun v : E => (p,v))
      ((0 : E →L[ℝ] E).prod (ContinuousLinearMap.id ℝ E)) p :=
    (hasFDerivAt_const p p).prodMk (hasFDerivAt_id (𝕜 := ℝ) p)
  have hD₂ := ((hdf.hasFDerivAt.comp (f := fun v : E => (p,v)) p hL₂).clm_apply
    (hasFDerivAt_const (k,(0:E)) p)).fderiv
  have hz₂ : fderiv ℝ (fun v : E => fderiv ℝ F (p,v) (k,0)) p=0 := by
    have heq : (fun v : E => fderiv ℝ F (p,v) (k,0)) =ᶠ[𝓝 p] (fun _ => (0:ℝ)) := hker
    rw [heq.fderiv_eq]
    exact (hasFDerivAt_const (0:ℝ) p).fderiv
  have hd₂ := congrArg (fun A : E →L[ℝ] ℝ => A k) (hD₂.symm.trans hz₂)
  simp only [add_apply,ContinuousLinearMap.comp_apply,
    zero_apply,map_zero,zero_add,ContinuousLinearMap.flip_apply,
    ContinuousLinearMap.prod_apply,ContinuousLinearMap.id_apply] at hd₂
  rw [(hF.isSymmSndFDerivAt (by simp)).eq] at hd₂
  have heq : (k,k)=(k,0)+((0:E),k) := by ext <;> simp
  rw [heq,map_add,add_apply,hd₂,zero_add] at hd₁
  exact hd₁
end

open Set Filter Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

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 second_leg_cost_smooth {x : M} {p : TangentSpace 𝓘(ℝ,Model n) x} {t : ℝ}
    (hright : (1-t) • (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).2 ∈
      injectivityDomain (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1) :
    ContMDiffAt (𝓘(ℝ,Model n).prod 𝓘(ℝ,Model n)) 𝓘(ℝ,ℝ) ∞
      (fun q : M×M => cost q.1 q.2) (riemannianExp x (t • p),riemannianExp x p) := by
  have hc := cost_contMDiffAt_of_injectivityDomain
    (⟨(sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).1,
      (1-t) • (sprayFlow t (⟨x,p⟩ : TangentBundle 𝓘(ℝ,Model n) M)).2⟩ :
      TangentBundle 𝓘(ℝ,Model n) M) hright
  dsimp only at hc
  rw [shifted_exp_endpoint] at hc
  simpa only [riemannianExp_smul] using hc

lemma diagonalSplitAction_endpoint_kernel {x : M} {p k : 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)
    (hk : mfderiv 𝓘(ℝ,TangentSpace 𝓘(ℝ,Model n) x) 𝓘(ℝ,Model n) (riemannianExp x) p k=0) :
    ∀ᶠ v : TangentSpace 𝓘(ℝ,Model n) x in 𝓝 p,
      fderiv ℝ (diagonalSplitAction x t) (p,v) (k,0)=0 := by
  let V := TangentSpace 𝓘(ℝ,Model n) x
  let y := riemannianExp x p
  have he := (contMDiff_riemannianExp_fiber (n := n) x).mdifferentiable (by simp)
  have hc := (second_leg_cost_smooth hright).of_le (m := 1) (by simp)
  have hcn : ∀ᶠ z : M×M in 𝓝 (riemannianExp x (t • p),y),
      ContMDiffAt (𝓘(ℝ,Model n).prod 𝓘(ℝ,Model n)) 𝓘(ℝ,ℝ) 1
        (fun q : M×M => cost q.1 q.2) z :=
    (contMDiffAt_iff_contMDiffAt_nhds (by norm_num)).mp hc
  have hj : Continuous (fun v : V => (riemannianExp x (t • v),y)) :=
    ((continuous_riemannianExp x).comp (by fun_prop)).prodMk continuous_const
  have hcnear := hj.continuousAt.eventually hcn
  have hF := diagonalSplitAction_contDiffAt hleft hright
  have hFn := (hF.of_le (m := 1) (by simp)).eventually (by norm_num)
  have hL : Continuous (fun v : V => (p,v)) := continuous_const.prodMk continuous_id
  have hFnear := hL.continuousAt.eventually hFn
  filter_upwards [hcnear,hFnear] with v hcv hFv
  change ContDiffAt ℝ 1 (diagonalSplitAction x t) (p,v) at hFv
  have hcost := (hcv.comp y (contMDiffAt_const.prodMk contMDiffAt_id)).mdifferentiableAt (by norm_num)
  have hD := hcost.hasMFDerivAt.comp p (he p).hasMFDerivAt
  have hD' : HasFDerivAt (fun w : V => cost (riemannianExp x (t • v)) (riemannianExp x w))
      ((mfderiv 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ) (fun z => cost (riemannianExp x (t • v)) z) y).comp
        (mfderiv 𝓘(ℝ,V) 𝓘(ℝ,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 : V => diagonalSplitAction x t (w,v)) =
      (fun w : V => 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 := (hFv.differentiableAt (by norm_num)).hasFDerivAt.comp
    (f := fun w : V => (w,v)) p hl
  have hh := congrArg (fun A : V →L[ℝ] ℝ => A k) (hfull.unique hpart)
  change fderiv ℝ (diagonalSplitAction x t) (p,v) (k,0) =
    (1-t)⁻¹ • (mfderiv 𝓘(ℝ,Model n) 𝓘(ℝ,ℝ)
      (fun z => cost (riemannianExp x (t • v)) z) y)
      (mfderiv 𝓘(ℝ,V) 𝓘(ℝ,Model n) (riemannianExp x) p k) at hh
  rw [hk,map_zero,smul_zero] at hh
  exact hh

lemma diagonalSplitAction_conjugate_hessian_null {x : M} {p k : TangentSpace 𝓘(ℝ,Model n) x}
    {t : ℝ} (ht : 0<t) (ht1 : t<1) (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)
    (hk : mfderiv 𝓘(ℝ,TangentSpace 𝓘(ℝ,Model n) x) 𝓘(ℝ,Model n) (riemannianExp x) p k=0) :
    fderiv ℝ (fderiv ℝ (diagonalSplitAction x t)) (p,p) (0,k) (0,k)=0 := by
  apply diagonal_stationary_hessian_null
    ((diagonalSplitAction_contDiffAt hleft hright).of_le
      (ENat.natCast_le_of_coe_top_le_withTop le_rfl 2))
  · exact (split_regular_legs_near hleft hright).mono
      (fun v hv => diagonalSplitAction_stationary ht ht1 hv.1 hv.2 k)
  · exact diagonalSplitAction_endpoint_kernel hleft hright hk

end WeakMTWTransport

end

end OAI