lean/OAI/Geometry/SmoothYau/Smoothness/FlowParameters.lean

import Mathlib
import OAI.Geometry.SmoothYau.Estimates.PathExtension

namespace OAI

noncomputable section
namespace YauCounterexamples
section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Metric
open scoped Topology ContDiff
universe u v
variable {K : Type v} {E F : Type u} [TopologicalSpace K] [CompactSpace K]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

local instance superpositionMapNorm : NormedAddCommGroup (E →L[ℝ] F) := inferInstance
local instance superpositionMapSpace : NormedSpace ℝ (E →L[ℝ] F) := inferInstance
local instance superpositionContinuousNorm : NormedAddCommGroup C(K, E) := inferInstance
local instance superpositionContinuousSpace : NormedSpace ℝ C(K, E) := inferInstance
local instance superpositionContinuousMapNorm : NormedAddCommGroup C(K, E →L[ℝ] F) := inferInstance
local instance superpositionContinuousMapSpace : NormedSpace ℝ C(K, E →L[ℝ] F) := inferInstance

def continuousMapApply (A : C(K, E →L[ℝ] F)) : C(K, E) →L[ℝ] C(K, F) := by
  let L : C(K, E) →ₗ[ℝ] C(K, F) :=
    { toFun := fun u => ⟨fun x => A x (u x), A.continuous.clm_apply u.continuous⟩
      map_add' := fun u v => by ext x; exact map_add (A x) (u x) (v x)
      map_smul' := fun c u => by ext x; exact map_smul (A x) c (u x) }
  exact L.mkContinuous ‖A‖ (fun u =>
    (ContinuousMap.norm_le (L u) (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr
      (fun x => ((A x).le_opNorm (u x)).trans
        (mul_le_mul (A.norm_coe_le_norm x) (u.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _))))

@[simp] lemma continuousMapApply_apply (A : C(K, E →L[ℝ] F)) (u : C(K, E)) (x : K) :
    continuousMapApply A u x = A x (u x) := rfl

lemma continuousMapApply_norm_le (A : C(K, E →L[ℝ] F)) :
    ‖continuousMapApply A‖ ≤ ‖A‖ :=
  ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg A) (fun u =>
    (ContinuousMap.norm_le (continuousMapApply A u) (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr
      (fun x => ((A x).le_opNorm (u x)).trans
        (mul_le_mul (A.norm_coe_le_norm x) (u.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _))))

def continuousMapApplyCLM : C(K, E →L[ℝ] F) →L[ℝ] (C(K, E) →L[ℝ] C(K, F)) := by
  let L : C(K, E →L[ℝ] F) →ₗ[ℝ] (C(K, E) →L[ℝ] C(K, F)) :=
    { toFun := continuousMapApply
      map_add' := fun A B => by ext u x; rfl
      map_smul' := fun c A => by ext u x; rfl }
  refine LinearMap.mkContinuous (𝕜 := ℝ) (𝕜₂ := ℝ)
    (E := C(K, E →L[ℝ] F)) (F := C(K, E) →L[ℝ] C(K, F)) L 1 ?_
  intro A
  change ‖continuousMapApply A‖ ≤ 1 * ‖A‖
  simpa only [one_mul] using continuousMapApply_norm_le A

def superposition (f : E → F) (hf : Continuous f) : C(K, E) → C(K, F) :=
  fun u => ⟨f ∘ u, hf.comp u.continuous⟩

omit [CompactSpace K] [NormedSpace ℝ E] [NormedSpace ℝ F] in
@[simp] lemma superposition_apply (f : E → F) (hf : Continuous f) (u : C(K, E)) (x : K) :
    superposition f hf u x = f (u x) := rfl

variable [FiniteDimensional ℝ E]

lemma hasFDerivAt_superposition {f : E → F} (hf : ContDiff ℝ ∞ f) (u : C(K, E)) :
    HasFDerivAt (superposition f hf.continuous)
      (continuousMapApply ⟨(fderiv ℝ f) ∘ u, (hf.continuous_fderiv (by simp)).comp u.continuous⟩) u := by
  rw [hasFDerivAt_iff_isLittleO_nhds_zero, Asymptotics.isLittleO_iff]
  intro ε hε
  have huc := (isCompact_closedBall (0 : E) (‖u‖ + 1)).uniformContinuousOn_of_continuous
    (hf.continuous_fderiv (by simp)).continuousOn
  obtain ⟨δ, hδ, hbound⟩ := Metric.uniformContinuousOn_iff.mp huc ε hε
  let r := min δ 1
  have hr : 0 < r := lt_min hδ zero_lt_one
  filter_upwards [continuous_norm.continuousAt.eventually_lt_const
    (show ‖(0 : C(K, E))‖ < r by simpa using hr)] with h hh
  apply (ContinuousMap.norm_le _ (mul_nonneg hε.le (norm_nonneg _))).mpr
  intro x
  have hx : u x ∈ closedBall (0 : E) (‖u‖ + 1) := by
    rw [mem_closedBall, dist_zero_right]
    exact (u.norm_coe_le_norm x).trans (le_add_of_nonneg_right zero_le_one)
  have hs : ball (u x) r ⊆ closedBall (0 : E) (‖u‖ + 1) := by
    intro y hy
    rw [mem_closedBall, dist_zero_right]
    calc ‖y‖ ≤ ‖y - u x‖ + ‖u x‖ := by simpa only [add_comm] using norm_le_insert' y (u x)
         _ ≤ 1 + ‖u‖ := add_le_add (by simpa only [dist_eq_norm] using (mem_ball.mp hy).le.trans (min_le_right δ 1))
           (u.norm_coe_le_norm x)
         _ = ‖u‖ + 1 := add_comm _ _
  have hderiv : ∀ y ∈ ball (u x) r, ‖fderiv ℝ f y - fderiv ℝ f (u x)‖ ≤ ε := by
    intro y hy
    simpa only [dist_eq_norm] using (hbound y (hs hy) (u x) hx
      ((mem_ball.mp hy).trans_le (min_le_left _ _))).le
  have hhx : u x + h x ∈ ball (u x) r := by
    rw [mem_ball, dist_eq_norm, add_sub_cancel_left]
    exact (h.norm_coe_le_norm x).trans_lt hh
  have hb := (convex_ball (u x) r).norm_image_sub_le_of_norm_fderiv_le'
    (fun y _ => hf.differentiable (by simp) y) hderiv (mem_ball_self hr) hhx
  simpa only [ContinuousMap.sub_apply, ContinuousMap.add_apply, superposition_apply,
      continuousMapApply_apply, ContinuousMap.coe_mk, Function.comp_apply, add_sub_cancel_left]
    using (by simpa only [add_sub_cancel_left] using hb :
      ‖f (u x + h x) - f (u x) - fderiv ℝ f (u x) (h x)‖ ≤ ε * ‖h x‖).trans
        (mul_le_mul_of_nonneg_left (h.norm_coe_le_norm x) hε.le)

lemma contDiff_nat_superposition (n : ℕ) :
    ∀ {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
      (f : E → F) (hf : ContDiff ℝ ∞ f), ContDiff ℝ n (superposition (K := K) f hf.continuous) := by
  induction n with
  | zero =>
    intro F _ _ f hf
    exact contDiff_zero.mpr (Differentiable.continuous (fun u => (hasFDerivAt_superposition hf u).differentiableAt))
  | succ n ih =>
    intro F _ _ f hf
    rw [show (↑(n + 1) : WithTop ℕ∞) = (n : WithTop ℕ∞) + 1 by push_cast; rfl,
      contDiff_succ_iff_hasFDerivAt]
    refine ⟨fun u => continuousMapApplyCLM (superposition (fderiv ℝ f)
      (hf.continuous_fderiv (by simp)) u), ?_, ?_⟩
    · exact (continuousMapApplyCLM (K := K) (E := E) (F := F)).contDiff.comp
        (ih (fderiv ℝ f) (hf.fderiv_right (by simp)))
    · intro u
      exact hasFDerivAt_superposition hf u

theorem contDiff_superposition {f : E → F} (hf : ContDiff ℝ ∞ f) :
    ContDiff ℝ ∞ (superposition (K := K) f hf.continuous) := by
  rw [contDiff_infty]
  exact fun n => contDiff_nat_superposition n f hf


end

section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Metric
open scoped Topology ContDiff
open Set Filter Metric MeasureTheory intervalIntegral
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
variable {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace X]

theorem smooth_inverse_on {f : X → X} (hf : ContDiff ℝ ∞ f) (x : X)
    (D : X ≃L[ℝ] X) (hd : HasFDerivAt f (D : X →L[ℝ] X) x) :
    ∃ (e : OpenPartialHomeomorph X X) (W : Set X),
      (e : X → X) = f ∧ x ∈ e.source ∧ IsOpen W ∧ f x ∈ W ∧ W ⊆ e.target ∧
      ContDiffOn ℝ ∞ e.symm W := by
  let e := hf.contDiffAt.toOpenPartialHomeomorph f hd (by simp)
  have hex : x ∈ e.source := hf.contDiffAt.mem_toOpenPartialHomeomorph_source hd (by simp)
  have hefx : f x ∈ e.target := e.map_source hex
  have hunit : ∀ᶠ z in 𝓝 x, IsUnit (fderiv ℝ f z) := by
    apply (hf.continuous_fderiv (by simp)).continuousAt.eventually
    apply Units.isOpen.mem_nhds
    rw [hd.fderiv]
    exact ContinuousLinearMap.isUnit_iff_bijective.mpr D.bijective
  have hu : ∀ᶠ y in 𝓝 (f x), IsUnit (fderiv ℝ f (e.symm y)) := by
    have hc : Tendsto e.symm (𝓝 (f x)) (𝓝 x) := by
      have hc := e.symm.continuousAt hefx
      change Tendsto e.symm (𝓝 (f x)) (𝓝 (e.symm (f x))) at hc
      have he : e.symm (f x) = x := e.left_inv hex
      rwa [he] at hc
    exact hc.eventually hunit
  obtain ⟨W, hWsub, hWo, hW⟩ := _root_.mem_nhds_iff.mp (hu.and (e.open_target.mem_nhds hefx))
  refine ⟨e, W, rfl, hex, hWo, hW, fun y hy => (hWsub hy).2, ?_⟩
  intro y hy
  obtain ⟨huy, hyt⟩ := hWsub hy
  have hb := ContinuousLinearMap.isUnit_iff_bijective.mp huy
  let A := ContinuousLinearEquiv.ofBijective (fderiv ℝ f (e.symm y))
    (LinearMap.ker_eq_bot.mpr hb.1) (LinearMap.range_eq_top.mpr hb.2)
  have ha : HasFDerivAt (e : X → X) (A : X →L[ℝ] X) (e.symm y) :=
    hf.differentiable (by simp) (e.symm y) |>.hasFDerivAt
  exact (e.contDiffAt_symm hyt ha (hf.contDiffAt)).contDiffWithinAt

end

open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Metric
open scoped Topology ContDiff
open Set Filter Metric MeasureTheory intervalIntegral
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology Manifold ContDiff ENNReal NNReal
open Set Filter Function Metric
open scoped Topology ContDiff
universe u
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]

abbrev FlowParameters (E : Type u) [TopologicalSpace E] := (ℝ × E) × C(unitInterval, E)

def flowIntegralMap (V : E → E) (hV : Continuous V) (p : FlowParameters E) : FlowParameters E :=
  (p.1, p.2 - ContinuousMap.const unitInterval p.1.2 - p.1.1 • volterra (superposition V hV p.2))

lemma flowIntegralMap_smooth {V : E → E} (hV : ContDiff ℝ ∞ V) :
    ContDiff ℝ ∞ (flowIntegralMap V hV.continuous) := by
  refine contDiff_fst.prodMk ((contDiff_snd.sub ?_).sub ?_)
  · exact (ContinuousLinearMap.const ℝ unitInterval : E →L[ℝ] C(unitInterval, E)).contDiff.comp contDiff_fst.snd
  · exact contDiff_fst.fst.smul (volterra.contDiff.comp ((contDiff_superposition hV).comp contDiff_snd))

def flowIntegralDerivative (S : C(unitInterval, E)) : FlowParameters E ≃L[ℝ] FlowParameters E where
  toFun p := (p.1, p.2 - ContinuousMap.const unitInterval p.1.2 - p.1.1 • S)
  invFun p := (p.1, p.2 + ContinuousMap.const unitInterval p.1.2 + p.1.1 • S)
  left_inv p := by ext <;> simp; abel
  right_inv p := by ext <;> simp; abel
  map_add' p q := by ext <;> simp [add_smul]; abel
  map_smul' c p := by ext <;> simp [smul_sub, smul_smul]
  continuous_toFun := by fun_prop
  continuous_invFun := by fun_prop

lemma flowIntegralMap_derivative {V : E → E} (hV : ContDiff ℝ ∞ V) (x : E) :
    HasFDerivAt (flowIntegralMap V hV.continuous)
      (flowIntegralDerivative (volterra (superposition V hV.continuous (ContinuousMap.const unitInterval x))) :
        FlowParameters E →L[ℝ] FlowParameters E) ((0,x), ContinuousMap.const unitInterval x) := by
  let p : FlowParameters E := ((0,x), ContinuousMap.const unitInterval x)
  let P := ContinuousLinearMap.fst ℝ (ℝ × E) C(unitInterval, E)
  let U := ContinuousLinearMap.snd ℝ (ℝ × E) C(unitInterval, E)
  let T := (ContinuousLinearMap.fst ℝ ℝ E).comp P
  let X := (ContinuousLinearMap.snd ℝ ℝ E).comp P
  have hQ := volterra.hasFDerivAt.comp p
    (((contDiff_superposition hV).differentiable (by simp) (U p)).hasFDerivAt.comp p U.hasFDerivAt)
  have hh := P.hasFDerivAt (x := p) |>.prodMk
    ((U.hasFDerivAt.sub ((ContinuousLinearMap.const ℝ unitInterval).hasFDerivAt.comp p X.hasFDerivAt)).sub
      (T.hasFDerivAt.smul hQ))
  convert! hh using 1
  ext q s <;> simp [flowIntegralDerivative, p, P, U, T, X]

theorem smooth_integral_paths {V : E → E} (hV : ContDiff ℝ ∞ V) (x : E) :
    ∃ (O : Set (ℝ × E)) (u : (ℝ × E) → C(unitInterval, E)),
      IsOpen O ∧ (0,x) ∈ O ∧ ContDiffOn ℝ ∞ u O ∧ u (0,x) = ContinuousMap.const unitInterval x ∧
      ∀ p ∈ O, u p = ContinuousMap.const unitInterval p.2 + p.1 • volterra (superposition V hV.continuous (u p)) := by
  let p : FlowParameters E := ((0,x), ContinuousMap.const unitInterval x)
  let D := flowIntegralDerivative (volterra (superposition V hV.continuous (ContinuousMap.const unitInterval x)))
  obtain ⟨e, W, hef, hep, hWo, hpW, hWt, hWs⟩ := smooth_inverse_on
    (flowIntegralMap_smooth hV) p D (flowIntegralMap_derivative hV x)
  let z : ℝ × E → FlowParameters E := fun q => (q,0)
  have hzp : z (0,x) = flowIntegralMap V hV.continuous p := by
    simp [z, flowIntegralMap, p]
  refine ⟨z ⁻¹' W, fun q => (e.symm (z q)).2, hWo.preimage (by fun_prop), ?_, ?_, ?_, ?_⟩
  · change z (0,x) ∈ W
    rwa [hzp]
  · exact (hWs.comp (f := z) (s := z ⁻¹' W) (by dsimp [z]; fun_prop) (fun q hq => hq)).snd
  · have he : e.symm (z (0,x)) = p := by
      rw [hzp, ← hef]
      exact e.left_inv hep
    exact congrArg Prod.snd he
  · intro q hq
    have he : flowIntegralMap V hV.continuous (e.symm (z q)) = z q := by
      rw [← hef]
      exact e.right_inv (hWt hq)
    have he1 : (e.symm (z q)).1 = q := congrArg Prod.fst he
    have he2 := congrArg Prod.snd he
    change (e.symm (z q)).2 - ContinuousMap.const unitInterval (e.symm (z q)).1.2 -
      (e.symm (z q)).1.1 • volterra (superposition V hV.continuous (e.symm (z q)).2) = 0 at he2
    rw [he1] at he2
    simpa only [sub_eq_zero, eq_sub_iff_add_eq, sub_eq_iff_eq_add, add_comm, zero_add] using he2


end YauCounterexamples
end

end OAI