lean/OAI/MathematicalPhysics/NavierStokes/VelocityDetection/CompactTails.lean

import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.TailDifferentiability
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.TailCompleteness

namespace OAI

noncomputable section
namespace VelocityDetection.TailSpace
open scoped BigOperators Topology ContDiff
open Set Function Filter
open Set Function Filter MeasureTheory
open scoped Topology BigOperators ContDiff
open scoped Topology ContDiff BigOperators
open scoped Topology ContDiff ZeroAtInfty

def ofCompact {n : ℕ} (f : Coord n → ℝ)
    (hf : Continuous f) (hc : HasCompactSupport f) : compatible n :=
  ⟨(⟨⟨f, hf⟩, hc.is_zero_at_infty⟩,
     (memLp_one_iff_integrable.mpr (hf.integrable_of_hasCompactSupport hc)).toLp f),
    (memLp_one_iff_integrable.mpr (hf.integrable_of_hasCompactSupport hc)).coeFn_toLp⟩

@[simp] theorem ofCompact_apply {n : ℕ} (f : Coord n → ℝ)
    (hf : Continuous f) (hc : HasCompactSupport f) (X : Coord n) :
    (ofCompact f hf hc).val.1 X = f X := rfl

theorem ext_fun {n : ℕ} {v w : compatible n}
    (h : ∀ X, v.val.1 X = w.val.1 X) : v = w := by
  apply Subtype.ext
  apply Prod.ext
  · exact ZeroAtInftyContinuousMap.ext h
  · apply Lp.ext
    filter_upwards [v.property, w.property] with X hv hw
    exact hv.trans ((h X).trans hw.symm)

theorem norm_le_of_support {n : ℕ} (v : compatible n) {K : Set (Coord n)}
    (hK : IsCompact K) {B : ℝ} (hB : 0 ≤ B)
    (hs : ∀ X ∉ K, v.val.1 X = 0)
    (hb : ∀ X, ‖v.val.1 X‖ ≤ B) :
    ‖v‖ ≤ (1 + volume.real K) * B := by
  have h₀ : ‖v.val.1‖ ≤ B := by
    rw [← ZeroAtInftyContinuousMap.norm_toBCF_eq_norm]
    exact (BoundedContinuousFunction.norm_le hB).mpr hb
  have hi : Integrable (K.indicator (fun _ : Coord n => B)) volume := by
    exact (integrableOn_const (C := B) hK.measure_lt_top.ne).integrable_indicator hK.measurableSet
  have h₁ : ‖v.val.2‖ ≤ volume.real K * B := by
    rw [L1.norm_eq_integral_norm]
    have hv : (fun X => v.val.2 X) =ᵐ[volume] (fun X => v.val.1 X) := v.property
    calc
      (∫ X, ‖v.val.2 X‖) = ∫ X, ‖v.val.1 X‖ := integral_congr_ae (hv.fun_comp norm)
      _ ≤ ∫ X, K.indicator (fun _ : Coord n => B) X := by
        apply integral_mono_of_nonneg (Filter.Eventually.of_forall (fun _ => norm_nonneg _)) hi
        filter_upwards [] with X
        by_cases hX : X ∈ K
        · simpa only [Set.indicator_of_mem hX] using hb X
        · simp [hX, hs X hX]
      _ = volume.real K * B := by
        rw [integral_indicator hK.measurableSet, setIntegral_const]
        rfl
  change max ‖v.val.1‖ ‖v.val.2‖ ≤ _
  refine max_le ?_ ?_
  · nlinarith [measureReal_nonneg (μ := (volume : Measure (Coord n))) (s := K)]
  · nlinarith [measureReal_nonneg (μ := (volume : Measure (Coord n))) (s := K)]

def LocalHorizontalSupport (f : ScalarField 2) : Prop :=
  ∀ T : ℝ, 0 ≤ T → ∃ K : Set (Coord 2), IsCompact K ∧
    ∀ t, |t| ≤ T → ∀ X ∉ K, f t X = 0

theorem LocalHorizontalSupport.slice {f : ScalarField 2}
    (hf : LocalHorizontalSupport f) (t : ℝ) : HasCompactSupport (f t) := by
  obtain ⟨K, hK, hzero⟩ := hf |t| (abs_nonneg _)
  apply HasCompactSupport.of_support_subset_isCompact hK
  intro X hX
  by_contra hnot
  exact hX (hzero t le_rfl X hnot)

theorem continuous_intersection_of_support (F : ℝ → compatible 2)
    (hf : Continuous (fun q : ℝ × Coord 2 => (F q.1).val.1 q.2))
    (hs : LocalHorizontalSupport (fun t X => (F t).val.1 X)) : Continuous F := by
  rw [continuous_iff_continuousAt]
  intro t
  obtain ⟨K, hK, hzero⟩ := hs (|t| + 1) (by positivity)
  change ∀ r, |r| ≤ |t| + 1 → ∀ X ∉ K, (F r).val.1 X = 0 at hzero
  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
  let G : C(ℝ, C(K, ℝ)) := ContinuousMap.curry ⟨fun q : ℝ × K => (F q.1).val.1 q.2.val,
    hf.comp (continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd))⟩
  have hG : Continuous G := G.continuous
  have hT : ∀ᶠ s in 𝓝 t, |s| ≤ |t| + 1 := by
    filter_upwards [(continuous_abs.tendsto t).eventually (gt_mem_nhds (by linarith : |t| < |t| + 1))] with s hs
    exact hs.le
  change Tendsto F (𝓝 t) (𝓝 (F t))
  rw [Metric.tendsto_nhds]
  intro ε hε
  have hV : 0 ≤ volume.real K := measureReal_nonneg
  have hC : 0 < 1 + volume.real K := by linarith
  have hε' : 0 < ε / (2 * (1 + volume.real K)) := div_pos hε (by positivity)
  have H := (Metric.tendsto_nhds.mp (hG.tendsto t)) _ hε'
  filter_upwards [H, hT] with s hdist hst
  rw [dist_eq_norm] at hdist
  change dist (F s).val (F t).val < ε
  rw [dist_eq_norm]
  change ‖F s - F t‖ < ε
  have hbound (X : Coord 2) : ‖(F s - F t).val.1 X‖ ≤ ε / (2 * (1 + volume.real K)) := by
    by_cases hX : X ∈ K
    · calc
        ‖(F s - F t).val.1 X‖ = ‖(G s - G t) ⟨X, hX⟩‖ := rfl
        _ ≤ ‖G s - G t‖ := ContinuousMap.norm_coe_le_norm _ _
        _ ≤ _ := hdist.le
    · change ‖(F s).val.1 X - (F t).val.1 X‖ ≤ _
      rw [hzero s hst X hX, hzero t (by linarith [le_abs_self t] : |t| ≤ |t| + 1) X hX]
      simpa using hε'.le
  have hz (X : Coord 2) (hX : X ∉ K) : (F s - F t).val.1 X = 0 := by
    change (F s).val.1 X - (F t).val.1 X = 0
    rw [hzero s hst X hX, hzero t (by linarith : |t| ≤ |t| + 1) X hX, sub_self]
  have hh := norm_le_of_support (F s - F t) hK hε'.le hz hbound
  have heq : (1 + volume.real K) * (ε / (2 * (1 + volume.real K))) = ε / 2 := by
    field_simp [hC.ne']
  exact hh.trans_lt (by rw [heq]; linarith)

theorem continuous_ofCompact_curve {f : ScalarField 2}
    (hf : Continuous (uncurry f)) (hs : LocalHorizontalSupport f) :
    Continuous (fun t => ofCompact (f t)
      (hf.comp (continuous_const.prodMk continuous_id)) (hs.slice t)) := by
  apply continuous_intersection_of_support
  · exact hf
  · exact hs

theorem LocalHorizontalSupport.dAlong {f : ScalarField 2}
    (hf : LocalHorizontalSupport f) (v : ℝ × Coord 2) :
    LocalHorizontalSupport (fun t X => JointCalculus.dAlong v (uncurry f) (t, X)) := by
  intro T hT
  obtain ⟨K, hK, hzero⟩ := hf (T + 1) (by linarith)
  refine ⟨K, hK, ?_⟩
  intro t ht X hX
  have ht' : ∀ᶠ q : ℝ × Coord 2 in 𝓝 (t, X), |q.1| < T + 1 :=
    (isOpen_lt (continuous_abs.comp continuous_fst) continuous_const).mem_nhds (by
      change |t| < T + 1
      linarith)
  have hX' : ∀ᶠ q : ℝ × Coord 2 in 𝓝 (t, X), q.2 ∉ K :=
    (hK.isClosed.isOpen_compl.preimage continuous_snd).mem_nhds hX
  have heq : uncurry f =ᶠ[𝓝 (t, X)] (fun _ => (0 : ℝ)) := by
    filter_upwards [ht', hX'] with q hq hqK
    exact hzero q.1 hq.le q.2 hqK
  have hd := (JointCalculus.eventuallyEq_dAlong v heq).eq_of_nhds
  simpa only [JointCalculus.dAlong, fderiv_const_apply, zero_apply] using hd

theorem LocalHorizontalSupport.spatialD {f : ScalarField 2}
    (hs : LocalHorizontalSupport f) (hf : ContDiff ℝ ∞ (uncurry f)) (i : Fin 2) :
    LocalHorizontalSupport (spatialD i f) := by
  have heq : VelocityDetection.spatialD i f = fun t X => JointCalculus.dAlong (0, Pi.single i 1) (uncurry f) (t, X) :=
    funext fun t => funext fun X => JointCalculus.spatialD_eq hf i t X
  rw [heq]
  exact hs.dAlong _

theorem hasDerivAt_intersection {F dF : ℝ → compatible 2}
    (hdF : Continuous dF)
    (hder : ∀ t X, HasDerivAt (fun s => (F s).val.1 X) ((dF t).val.1 X) t) (t : ℝ) :
    HasDerivAt F (dF t) t := by
  have heq (s : ℝ) : F s = F 0 + ∫ r in (0 : ℝ)..s, dF r := by
    apply ext_fun
    intro X
    change (F s).val.1 X = eval X (F 0 + ∫ r in (0 : ℝ)..s, dF r)
    rw [map_add]
    have hint : (∫ r in (0 : ℝ)..s, eval X (dF r)) = eval X (∫ r in (0 : ℝ)..s, dF r) :=
      ContinuousLinearMap.intervalIntegral_comp_comm (𝕜 := ℝ) (μ := volume) (E := compatible 2) (F := ℝ)
        (eval X) (Continuous.intervalIntegrable (E := compatible 2) hdF 0 s)
    rw [← hint]
    have hc : Continuous (fun r => (dF r).val.1 X) := (eval X).continuous.comp hdF
    have hh := intervalIntegral.integral_eq_sub_of_hasDerivAt
      (fun r (_ : r ∈ uIcc (0 : ℝ) s) => hder r X) (hc.intervalIntegrable 0 s)
    simp only [eval_apply]
    rw [hh]
    ring
  have hm : StronglyMeasurable dF := Continuous.stronglyMeasurable hdF
  have H := HasDerivAt.const_add (F := compatible 2) (F 0)
    (intervalIntegral.integral_hasDerivAt_right (E := compatible 2)
      (Continuous.intervalIntegrable (E := compatible 2) hdF 0 t)
      hm.stronglyMeasurableAtFilter hdF.continuousAt)
  exact HasDerivAt.congr_of_eventuallyEq (F := compatible 2) H (Filter.Eventually.of_forall heq)

theorem c1Tails_of_smooth_support {f : ScalarField 2}
    (hf : ContDiff ℝ ∞ (uncurry f)) (hs : LocalHorizontalSupport f) : C1Tails f := by
  let g : ScalarField 2 := fun t X => JointCalculus.dAlong (1, 0) (uncurry f) (t, X)
  have hg : ContDiff ℝ ∞ (uncurry g) := JointCalculus.contDiff_dAlong _ hf
  have hgs : LocalHorizontalSupport g := hs.dAlong _
  let F : ℝ → compatible 2 := fun t => ofCompact (f t)
    (hf.continuous.comp (continuous_const.prodMk continuous_id)) (hs.slice t)
  let dF : ℝ → compatible 2 := fun t => ofCompact (g t)
    (hg.continuous.comp (continuous_const.prodMk continuous_id)) (hgs.slice t)
  have hdF : Continuous dF := continuous_ofCompact_curve hg.continuous hgs
  refine ⟨F, dF, (continuous_ofCompact_curve hf.continuous hs).continuousOn,
    hdF.continuousOn, fun _ _ => rfl, ?_⟩
  intro t ht
  apply HasDerivAt.hasDerivWithinAt (𝕜 := ℝ) (F := compatible 2) (hasDerivAt_intersection hdF ?_ t)
  intro s X
  change HasDerivAt (fun r => f r X) (JointCalculus.dAlong (1, 0) (uncurry f) (s, X)) s
  simpa only [comp_def, JointCalculus.dAlong, uncurry_apply_pair, id_eq] using
    ((hf.differentiable (by simp) (s, X)).hasFDerivAt.comp_hasDerivAt s
      ((hasDerivAt_id s).prodMk (hasDerivAt_const s X)))

theorem spatial_c1Tails_of_smooth_support {f : ScalarField 2}
    (hf : ContDiff ℝ ∞ (uncurry f)) (hs : LocalHorizontalSupport f) (i : Fin 2) :
    C1Tails (spatialD i f) := by
  have hdiff : ContDiff ℝ ∞ (uncurry (spatialD i f)) := by
    have heq : uncurry (spatialD i f) = JointCalculus.dAlong (0, Pi.single i 1) (uncurry f) :=
      funext fun q => JointCalculus.spatialD_eq hf i q.1 q.2
    rw [heq]
    exact JointCalculus.contDiff_dAlong _ hf
  exact c1Tails_of_smooth_support hdiff (hs.spatialD hf i)

theorem second_continuousTails_of_smooth_support {f : ScalarField 2}
    (hf : ContDiff ℝ ∞ (uncurry f)) (hs : LocalHorizontalSupport f) (i k : Fin 2) :
    ContinuousTails (spatialD k (spatialD i f)) := by
  have hdiff : ContDiff ℝ ∞ (uncurry (spatialD i f)) := by
    have heq : uncurry (spatialD i f) = JointCalculus.dAlong (0, Pi.single i 1) (uncurry f) :=
      funext fun q => JointCalculus.spatialD_eq hf i q.1 q.2
    rw [heq]
    exact JointCalculus.contDiff_dAlong _ hf
  exact (spatial_c1Tails_of_smooth_support hdiff (hs.spatialD hf i) k).continuous

end VelocityDetection.TailSpace
end

end OAI