lean/OAI/MathematicalPhysics/SheetFlows/RectangleGeometry.lean

import Mathlib
import OAI.MathematicalPhysics.SheetFlows.Model

namespace OAI

/-! SheetFlows rectangle geometry. -/

noncomputable section
open Set MeasureTheory
open scoped BigOperators
namespace Solenoidal

namespace Rectangle

theorem halfWidth_pos (R : Rectangle) (j : Fin 2) : 0 < R.halfWidth j := by
  have h : (R.lower j : ℝ) < (R.upper j : ℝ) := by exact_mod_cast R.positive j
  dsimp [halfWidth]
  linarith

theorem center_sub_halfWidth (R : Rectangle) (j : Fin 2) :
    R.center j - R.halfWidth j = (R.lower j : ℝ) := by
  dsimp [center, halfWidth]
  ring

theorem center_add_halfWidth (R : Rectangle) (j : Fin 2) :
    R.center j + R.halfWidth j = (R.upper j : ℝ) := by
  dsimp [center, halfWidth]
  ring

theorem mem_iff_abs (R : Rectangle) (y : Plane) :
    y ∈ R.carrier ↔ ∀ j, |y j - R.center j| ≤ R.halfWidth j := by
  simp only [carrier, Set.mem_ofPred_eq, abs_le]
  constructor
  · intro h j
    have hl := (h j).1
    have hu := (h j).2
    dsimp [center, halfWidth]
    constructor <;> linarith
  · intro h j
    have hl := (h j).1
    have hu := (h j).2
    dsimp [center, halfWidth] at hl hu
    constructor <;> linarith

theorem center_mem (R : Rectangle) : R.center ∈ R.carrier := by
  rw [mem_iff_abs]
  intro j
  simpa using le_of_lt (halfWidth_pos R j)

theorem upper_mem (R : Rectangle) : (fun j => (R.upper j : ℝ)) ∈ R.carrier := by
  intro j
  have h : (R.lower j : ℝ) < (R.upper j : ℝ) := by exact_mod_cast R.positive j
  exact ⟨h.le, le_rfl⟩

theorem halfWidth_le_half (R : Rectangle) (h : R.inCodingSquare) (j : Fin 2) :
    R.halfWidth j ≤ 1 / 2 := by
  have hl : (2 : ℝ) ≤ R.lower j := by exact_mod_cast (h j).1
  have hu : (R.upper j : ℝ) ≤ 3 := by exact_mod_cast (h j).2
  dsimp [halfWidth]
  linarith

theorem offset_bound (R : Rectangle) (hR : R.inCodingSquare)
    {y : Plane} (hy : y ∈ R.carrier) (j : Fin 2) :
    |y j - R.center j| ≤ 1 / 2 :=
  ((R.mem_iff_abs y).mp hy j).trans (R.halfWidth_le_half hR j)

end Rectangle

theorem diagonalMap_upper (P Q : Rectangle) (r : Fin 2 → ℚ)
    (hr : ∀ j, 0 < r j)
    (himage : diagonalMap P Q r '' P.carrier = Q.carrier) :
    diagonalMap P Q r (fun j => (P.upper j : ℝ)) = fun j => (Q.upper j : ℝ) := by
  have hmax : ∀ y ∈ P.carrier, ∀ j,
      diagonalMap P Q r y j ≤ diagonalMap P Q r (fun k => (P.upper k : ℝ)) j := by
    intro y hy j
    have hj : (0 : ℝ) ≤ (r j : ℝ) := by exact_mod_cast (hr j).le
    dsimp [diagonalMap]
    exact add_le_add le_rfl
      (mul_le_mul_of_nonneg_left (sub_le_sub_right (hy j).2 _) hj)
  have hup : diagonalMap P Q r (fun j => (P.upper j : ℝ)) ∈ Q.carrier := by
    rw [← himage]
    exact ⟨_, P.upper_mem, rfl⟩
  obtain ⟨y, hy, he⟩ : ∃ y ∈ P.carrier,
      diagonalMap P Q r y = (fun j => (Q.upper j : ℝ)) := by
    have h := Q.upper_mem
    rw [← himage] at h
    exact h
  funext j
  apply le_antisymm (hup j).2
  simpa only [he] using hmax y hy j

theorem SheetData.ratio_mul_halfWidth {N : ℕ} (D : SheetData N)
    (i : Fin N) (j : Fin 2) :
    (D.ratio i j : ℝ) * (D.source i).halfWidth j = (D.target i).halfWidth j := by
  have h := congrFun (diagonalMap_upper (D.source i) (D.target i) (D.ratio i)
    (D.ratio_positive i) (D.image_eq i)) j
  dsimp [diagonalMap, Rectangle.center] at h
  dsimp [Rectangle.halfWidth]
  linarith

theorem SheetData.ratio_eq_halfWidth_ratio {N : ℕ} (D : SheetData N)
    (i : Fin N) (j : Fin 2) :
    (D.ratio i j : ℝ) = (D.target i).halfWidth j / (D.source i).halfWidth j := by
  apply (eq_div_iff (ne_of_gt ((D.source i).halfWidth_pos j))).mpr
  exact D.ratio_mul_halfWidth i j

theorem SheetData.scaled_offset_bound {N : ℕ} (D : SheetData N)
    (i : Fin N) {y : Plane} (hy : y ∈ (D.source i).carrier) (j : Fin 2) :
    |(D.ratio i j : ℝ) * (y j - (D.source i).center j)| ≤ 1 / 2 := by
  have hr : (0 : ℝ) < (D.ratio i j : ℝ) := by exact_mod_cast D.ratio_positive i j
  rw [abs_mul, abs_of_pos hr]
  calc
    (D.ratio i j : ℝ) * |y j - (D.source i).center j| ≤
        (D.ratio i j : ℝ) * (D.source i).halfWidth j :=
      mul_le_mul_of_nonneg_left (((D.source i).mem_iff_abs y).mp hy j) hr.le
    _ = (D.target i).halfWidth j := D.ratio_mul_halfWidth i j
    _ ≤ 1 / 2 := (D.target i).halfWidth_le_half (D.target_inside i) j

abbrev OffsetHeight := ℝ × ℝ

def verticalShear (a : ℝ) (p : OffsetHeight) : OffsetHeight :=
  (p.1, p.2 + a * p.1)

def horizontalShear (b : ℝ) (p : OffsetHeight) : OffsetHeight :=
  (p.1 + b * p.2, p.2)

def threeShears (κ μ : ℝ) (p : OffsetHeight) : OffsetHeight :=
  verticalShear (-κ / μ)
    (horizontalShear ((μ - 1) / κ) (verticalShear κ p))

theorem threeShears_action {κ μ : ℝ} (hκ : κ ≠ 0) (hμ : μ ≠ 0)
    (ξ ζ : ℝ) :
    threeShears κ μ (ξ, ζ) = (μ * ξ + (μ - 1) / κ * ζ, ζ / μ) := by
  ext <;> dsimp [threeShears, verticalShear, horizontalShear]
  · field_simp
    ring
  · field_simp
    ring

theorem threeShears_on_sheet {κ μ : ℝ} (hκ : κ ≠ 0) (hμ : μ ≠ 0) (ξ : ℝ) :
    threeShears κ μ (ξ, 0) = (μ * ξ, 0) := by
  simp [threeShears_action hκ hμ]

def coreMatrix₂ (κ μ : ℝ) : Matrix (Fin 2) (Fin 2) ℝ :=
  !![μ, (μ - 1) / κ; 0, 1 / μ]

theorem coreMatrix₂_det (κ : ℝ) {μ : ℝ} (hμ : μ ≠ 0) :
    (coreMatrix₂ κ μ).det = 1 := by
  simp [coreMatrix₂, Matrix.det_fin_two, hμ]

def tripleX (κ μ : ℝ) (x : Space) : Space :=
  ![(threeShears κ μ (x 0, x 2)).1, x 1, (threeShears κ μ (x 0, x 2)).2]

def tripleY (κ μ : ℝ) (x : Space) : Space :=
  ![x 0, (threeShears κ μ (x 1, x 2)).1, (threeShears κ μ (x 1, x 2)).2]

def sixShears (κ μ₁ μ₂ : ℝ) (x : Space) : Space :=
  tripleY κ μ₂ (tripleX κ μ₁ x)

theorem sixShears_action {κ μ₁ μ₂ : ℝ}
    (hκ : κ ≠ 0) (h₁ : μ₁ ≠ 0) (h₂ : μ₂ ≠ 0) (x : Space) :
    sixShears κ μ₁ μ₂ x =
      ![μ₁ * x 0 + (μ₁ - 1) / κ * x 2,
        μ₂ * x 1 + (μ₂ - 1) / κ * (x 2 / μ₁),
        x 2 / (μ₁ * μ₂)] := by
  simp [sixShears, tripleX, tripleY, threeShears_action hκ h₁,
    threeShears_action hκ h₂, div_div]

theorem sixShears_on_sheet {κ μ₁ μ₂ : ℝ}
    (hκ : κ ≠ 0) (h₁ : μ₁ ≠ 0) (h₂ : μ₂ ≠ 0) (y : Plane) :
    sixShears κ μ₁ μ₂ ![y 0, y 1, 0] = ![μ₁ * y 0, μ₂ * y 1, 0] := by
  simp [sixShears_action hκ h₁ h₂]

def coreMatrix₃ (κ μ₁ μ₂ : ℝ) : Matrix (Fin 3) (Fin 3) ℝ :=
  !![μ₁, 0, (μ₁ - 1) / κ;
     0, μ₂, (μ₂ - 1) / (κ * μ₁);
     0, 0, 1 / (μ₁ * μ₂)]

theorem coreMatrix₃_mulVec {κ μ₁ μ₂ : ℝ}
    (hκ : κ ≠ 0) (h₁ : μ₁ ≠ 0) (h₂ : μ₂ ≠ 0) (x : Space) :
    (coreMatrix₃ κ μ₁ μ₂).mulVec x = sixShears κ μ₁ μ₂ x := by
  rw [sixShears_action hκ h₁ h₂]
  ext j
  fin_cases j <;> simp [coreMatrix₃, Matrix.mulVec, dotProduct, Fin.sum_univ_succ]
  all_goals ring

theorem coreMatrix₃_det (κ : ℝ) {μ₁ μ₂ : ℝ}
    (h₁ : μ₁ ≠ 0) (h₂ : μ₂ ≠ 0) :
    (coreMatrix₃ κ μ₁ μ₂).det = 1 := by
  simp [coreMatrix₃, Matrix.det_fin_three]
  field_simp

def centeredCore (p q : Plane) (height κ μ₁ μ₂ : ℝ) (x : Space) : Space :=
  ![q 0, q 1, height] + sixShears κ μ₁ μ₂ (x - ![p 0, p 1, height])

theorem centeredCore_on_sheet (P Q : Rectangle) (r : Fin 2 → ℚ)
    (hr : ∀ j, 0 < r j) (y : Plane) :
    centeredCore P.center Q.center 2 1 (r 0 : ℝ) (r 1 : ℝ) (sheet y) =
      sheet (diagonalMap P Q r y) := by
  have h₀ : (r 0 : ℝ) ≠ 0 := by exact_mod_cast ne_of_gt (hr 0)
  have h₁ : (r 1 : ℝ) ≠ 0 := by exact_mod_cast ne_of_gt (hr 1)
  rw [centeredCore, sixShears_action one_ne_zero h₀ h₁]
  ext j
  fin_cases j <;> simp [sheet, diagonalMap]

theorem abs_convex_combination_le {a b B θ : ℝ}
    (ha : |a| ≤ B) (hb : |b| ≤ B) (hθ₀ : 0 ≤ θ) (hθ₁ : θ ≤ 1) :
    |(1 - θ) * a + θ * b| ≤ B := by
  rcases abs_le.mp ha with ⟨ha₀, ha₁⟩
  rcases abs_le.mp hb with ⟨hb₀, hb₁⟩
  have hθ : 0 ≤ 1 - θ := sub_nonneg.mpr hθ₁
  apply abs_le.mpr
  constructor
  · have ea := mul_le_mul_of_nonneg_left ha₀ hθ
    have eb := mul_le_mul_of_nonneg_left hb₀ hθ₀
    nlinarith
  · have ea := mul_le_mul_of_nonneg_left ha₁ hθ
    have eb := mul_le_mul_of_nonneg_left hb₁ hθ₀
    nlinarith

theorem first_phase (ξ θ : ℝ) : verticalShear θ (ξ, 0) = (ξ, θ * ξ) := by
  simp [verticalShear]

theorem middle_phase (μ ξ θ : ℝ) :
    horizontalShear (θ * (μ - 1)) (verticalShear 1 (ξ, 0)) =
      ((1 - θ) * ξ + θ * (μ * ξ), ξ) := by
  ext <;> dsimp [horizontalShear, verticalShear] <;> ring

theorem last_phase {μ : ℝ} (hμ : μ ≠ 0) (ξ θ : ℝ) :
    verticalShear (-θ / μ)
        (horizontalShear (μ - 1) (verticalShear 1 (ξ, 0))) =
      (μ * ξ, (1 - θ) * ξ) := by
  ext <;> dsimp [horizontalShear, verticalShear]
  · ring
  · field_simp
    ring

theorem triple_path_bounds {μ ξ θ : ℝ} (hμ : μ ≠ 0)
    (hξ : |ξ| ≤ 1 / 2) (hμξ : |μ * ξ| ≤ 1 / 2)
    (hθ₀ : 0 ≤ θ) (hθ₁ : θ ≤ 1) :
    (|((verticalShear θ (ξ, 0)).1)| ≤ 1 / 2 ∧
      |((verticalShear θ (ξ, 0)).2)| ≤ 1 / 2) ∧
    (|((horizontalShear (θ * (μ - 1)) (verticalShear 1 (ξ, 0))).1)| ≤ 1 / 2 ∧
      |((horizontalShear (θ * (μ - 1)) (verticalShear 1 (ξ, 0))).2)| ≤ 1 / 2) ∧
    (|((verticalShear (-θ / μ)
        (horizontalShear (μ - 1) (verticalShear 1 (ξ, 0)))).1)| ≤ 1 / 2 ∧
      |((verticalShear (-θ / μ)
        (horizontalShear (μ - 1) (verticalShear 1 (ξ, 0)))).2)| ≤ 1 / 2) := by
  rw [first_phase, middle_phase, last_phase hμ]
  have hzero : |(0 : ℝ)| ≤ 1 / 2 := by norm_num
  have hfirst := abs_convex_combination_le hzero hξ hθ₀ hθ₁
  have hlast := abs_convex_combination_le hξ hzero hθ₀ hθ₁
  simp only [mul_zero, zero_add, add_zero] at hfirst hlast
  exact ⟨⟨hξ, hfirst⟩, ⟨abs_convex_combination_le hξ hμξ hθ₀ hθ₁, hξ⟩,
    ⟨hμξ, hlast⟩⟩

theorem processing_height_bound {ζ : ℝ} (hζ : |ζ| ≤ 1 / 2) :
    (9 / 2 : ℝ) ≤ 5 + ζ ∧ 5 + ζ ≤ 11 / 2 := by
  rcases abs_le.mp hζ with ⟨hl, hu⟩
  constructor <;> linarith

end Solenoidal
end

end OAI