lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Programs/BalancedLoader.lean

import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.BalancedActivation
import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.BalancedPlanarOrbit

namespace OAI

/-! One compact Hamiltonian translation loads the input point. The source
and target belong to a fixed rectangle, hence its whole straight path is
inside the cutoff plateau and outside the balanced cube after stretching. -/

noncomputable section
namespace ForcedComputation.BalancedLoader
open ShearFlows PlanarHamiltonian Set
open scoped ContDiff

def start : Plane := ![4, 0]
def rectangle : RationalBox 2 := ⟨![0, -1], ![4, 1]⟩
def direction (q : Plane) : Plane := q - start

def potential (q : Plane) (x : Plane) : ℝ :=
  rectangleCutoff rectangle 1 x * translationPotential (direction q) x

def spatial (q : Plane) : Plane → Plane := field (potential q)
def clock : ℝ → ℝ := smoothRamp (1 / 8) (1 / 4)
def pulse : ℝ → ℝ := smoothPulse (1 / 8) (1 / 4)
def planarVelocity (q : Plane) (t : ℝ) (x : Plane) : Plane := pulse t • spatial q x

def planarPath (q : Plane) (t : ℝ) : Plane := start + clock t • direction q

def raw (q : Plane) : Velocity := CompactLift.velocity BalancedBody.verticalCutoff (planarVelocity q)
def velocity (q : Plane) : Velocity := BalancedStretch.velocity (raw q)
def path (q : Plane) (t : ℝ) : Space := BalancedStretch.stretch (atHeight (planarPath q t) 0)

theorem spatial_smooth (q : Plane) : ContDiff ℝ ∞ (spatial q) :=
  field_smooth ((rectangleCutoff_smooth rectangle 1).mul (translationPotential_smooth _))

theorem planarVelocity_smooth (q : Plane) :
    ContDiff ℝ ∞ (fun y : ℝ × Plane => planarVelocity q y.1 y.2) :=
  ((smoothPulse_smooth _ _).comp contDiff_fst).smul ((spatial_smooth q).comp contDiff_snd)

theorem velocity_smooth (q : Plane) : ContDiff ℝ ∞ (velocity q) :=
  BalancedStretch.velocity_smooth
    (CompactLift.velocity_smooth BalancedBody.verticalCutoff_smooth (planarVelocity_smooth q))

theorem planarPath_in_rectangle {q : Plane} (hq : ∀ j, 0 ≤ q j ∧ q j ≤ 1) (t : ℝ) :
    planarPath q t ∈ rectangle.carrier := by
  have hc := smoothRamp_range (1 / 8) (1 / 4) t
  obtain ⟨hc0, hc1⟩ := hc
  intro j
  fin_cases j
  · norm_num [rectangle, planarPath, direction, start, Matrix.vecHead, Matrix.vecTail]
    dsimp only [clock] at *
    constructor
    · nlinarith [mul_nonneg hc0 (hq 0).1]
    · have hp := mul_nonpos_of_nonneg_of_nonpos hc0
        (show q 0 - 4 ≤ 0 by linarith [(hq 0).2])
      nlinarith
  · norm_num [rectangle, planarPath, direction, start, Matrix.vecHead, Matrix.vecTail]
    dsimp only [clock] at *
    constructor
    · nlinarith [mul_nonneg hc0 (hq 1).1]
    · nlinarith [mul_le_mul hc1 (hq 1).2 (hq 1).1 (by norm_num : (0 : ℝ) ≤ 1)]

theorem spatial_on_rectangle (q : Plane) {x : Plane} (hx : x ∈ rectangle.carrier) :
    spatial q x = direction q := by
  change field (fun y => rectangleCutoff rectangle 1 y * translationPotential (direction q) y) x = _
  rw [field_cutoff_plateau _ _
    (rectangleCutoff_one_near (by norm_num : (0 : ℚ) < 1) hx), field_translation]

theorem planarPath_deriv {q : Plane} (hq : ∀ j, 0 ≤ q j ∧ q j ≤ 1) (t : ℝ) :
    HasDerivAt (planarPath q) (planarVelocity q t (planarPath q t)) t := by
  have hθ : HasDerivAt clock (pulse t) t :=
    ((smoothRamp_smooth (1 / 8) (1 / 4)).differentiable (by simp) t).hasDerivAt
  have hd := (hθ.smul_const (direction q)).const_add start
  have he : planarVelocity q t (planarPath q t) = pulse t • direction q := by
    rw [planarVelocity, spatial_on_rectangle q (planarPath_in_rectangle hq t)]
  rw [he]
  exact hd

theorem path_deriv {q : Plane} (hq : ∀ j, 0 ≤ q j ∧ q j ≤ 1) (t : ℝ) :
    HasDerivAt (path q) (velocity q (t, path q t)) t := by
  have h := CompactLift.trajectory_atHeight (V := planarVelocity q) (a := 0)
    BalancedBody.verticalCutoff_zero (by simpa only [zero_add] using planarPath_deriv hq t)
  apply hasDerivAt_pi.mpr
  intro j
  simpa only [zero_add, path, velocity, raw] using
    (hasDerivAt_pi.mp (BalancedStretch.trajectory h)) j

theorem path_before (q : Plane) {t : ℝ} (ht : t ≤ 1 / 8) :
    path q t = ![4, 0, 0] := by
  have hc : clock t = 0 := smoothRamp_before (by norm_num) ht
  ext j
  fin_cases j <;> simp [path, planarPath, hc, start, BalancedStretch.coefficient, atHeight]

theorem path_after (q : Plane) {t : ℝ} (ht : 1 / 4 ≤ t) :
    path q t = BalancedStretch.stretch (atHeight q 0) := by
  have hc : clock t = 1 := smoothRamp_after (by norm_num) ht
  rw [path, planarPath, hc, one_smul, direction]
  congr 2
  abel

theorem path_safe {q : Plane} (hq : 4 ≤ q 0 + 16 * q 1) (t : ℝ) :
    path q t ∉ BalancedStretch.observer := by
  have hc := smoothRamp_range (1 / 8) (1 / 4) t
  have he : path q t = (1 - clock t) • ![4, 0, 0] +
      clock t • BalancedStretch.stretch (atHeight q 0) := by
    ext j
    fin_cases j <;> simp [path, planarPath, direction, start, atHeight,
      BalancedStretch.coefficient, Matrix.vecHead, Matrix.vecTail] <;> ring
  rw [he]
  apply BalancedStretch.loading_outside
  · simpa [BalancedStretch.coefficient, atHeight] using hq
  · exact hc

theorem velocity_before (q : Plane) {t : ℝ} (ht : t ≤ 1 / 8) (x : Space) :
    velocity q (t, x) = 0 := by
  have hp : pulse t = 0 := smoothPulse_before (by norm_num) ht
  simp [velocity, BalancedStretch.velocity, BalancedStretch.push, raw, CompactLift.velocity,
    CompactLift.spatial, VelocityDetector.triangularLift, planarVelocity, hp]

theorem velocity_after (q : Plane) {t : ℝ} (ht : 1 / 4 ≤ t) (x : Space) :
    velocity q (t, x) = 0 := by
  have hp : pulse t = 0 := smoothPulse_after (by norm_num) ht
  simp [velocity, BalancedStretch.velocity, BalancedStretch.push, raw, CompactLift.velocity,
    CompactLift.spatial, VelocityDetector.triangularLift, planarVelocity, hp]


def rawSupport : Set Space := Icc ![-2, -3, -2] ![6, 3, 2]
def support : Set Space := BalancedStretch.stretch '' rawSupport

theorem support_compact : IsCompact support :=
  (isCompact_Icc : IsCompact rawSupport).image BalancedStretch.stretch.continuous

theorem spatial_support (q : Plane) :
    tsupport (spatial q) ⊆ (rectangleCollar rectangle 1).carrier :=
  (field_tsupport (potential q)).trans
    (tsupport_mul_subset_left.trans (closure_minimal
      (rectangleCutoff_support (by norm_num : (0 : ℚ) < 1))
      (rectangleCollar_compact rectangle 1).isClosed))

theorem raw_support (q : Plane) (t : ℝ) :
    tsupport (fun x => raw q (t, x)) ⊆ rawSupport := by
  apply closure_minimal _ (isCompact_Icc : IsCompact rawSupport).isClosed
  intro x hx
  have hχ : BalancedBody.verticalCutoff (x 2) ≠ 0 := by
    intro hz
    apply hx
    simp only [raw, CompactLift.velocity, CompactLift.spatial, hz, zero_smul]
  have hV : spatial q (horizontal x) ≠ 0 := by
    intro hz
    apply hx
    simp only [raw, CompactLift.velocity, CompactLift.spatial, VelocityDetector.triangularLift,
      VelocityDetector.horizontalLinear_eq, planarVelocity, hz, smul_zero,
      map_zero, zero_smul, add_zero]
  have hp := spatial_support q (subset_tsupport _ hV)
  have hz := closedCutoff_support (by norm_num : (-2 : ℝ) < -1)
    (by norm_num : (1 : ℝ) < 2) hχ
  have h₀ := hp (0 : Fin 2)
  have h₁ := hp (1 : Fin 2)
  norm_num [rectangleCollar, rectangle] at h₀ h₁
  constructor <;> intro j <;> fin_cases j
  · exact h₀.1
  · exact h₁.1
  · exact hz.1.le
  · exact h₀.2
  · exact h₁.2
  · exact hz.2.le

theorem velocity_support (q : Plane) (t : ℝ) :
    tsupport (fun x => velocity q (t, x)) ⊆ support := by
  change tsupport (BalancedStretch.push (fun x => raw q (t,x))) ⊆
    BalancedStretch.stretch '' rawSupport
  exact BalancedStretch.push_support (a := fun x => raw q (t,x)) (K := rawSupport)
    (isCompact_Icc : IsCompact rawSupport).isClosed (raw_support q t)

theorem planarVelocity_divergence (q : Plane) (t : ℝ) (x : Plane) :
    PlanarHamiltonian.divergence (planarVelocity q t) x = 0 := by
  have he : planarVelocity q t = field (fun y => pulse t * potential q y) := by
    funext y
    exact (field_const_mul ((rectangleCutoff_smooth rectangle 1).mul
      (translationPotential_smooth _)) _ _).symm
  rw [he]
  exact field_divergence (contDiff_const.mul
    ((rectangleCutoff_smooth rectangle 1).mul (translationPotential_smooth _))) x

theorem raw_divergence (q : Plane) (t : ℝ) (x : Space) :
    divergence (fun y => raw q (t, y)) x = 0 := by
  have hs : ContDiff ℝ ∞ (planarVelocity q t) :=
    (contDiff_const : ContDiff ℝ ∞ (fun _ : Plane => pulse t)).smul (spatial_smooth q)
  rw [show (fun y => raw q (t, y)) =
    CompactLift.spatial BalancedBody.verticalCutoff (planarVelocity q t) from rfl,
    CompactLift.spatial_divergence BalancedBody.verticalCutoff_smooth hs,
    planarVelocity_divergence, mul_zero]

theorem velocity_divergence (q : Plane) : Solenoidal (velocity q) :=
  BalancedStretch.velocity_divergence (raw_divergence q)

end ForcedComputation.BalancedLoader

end

end OAI