import Mathlib
import OAI.Analysis.BoxTransport.Flow

namespace OAI

/-! Separated five-stage motions and explicit affine time-one delivery. -/

noncomputable section
open scoped Topology
open scoped BigOperators ContDiff

namespace BoxTransport.Routing
def centerKey {n : ℕ} (f : Fin n → ℚ) (i : Fin n) : ℚ ×ₗ ℕ := toLex (f i, i.val)

def coordinateRank {n : ℕ} (f : Fin n → ℚ) (i : Fin n) : ℕ :=
  (Finset.univ.filter fun j => centerKey f j < centerKey f i).card

theorem centerKey_injective {n : ℕ} (f : Fin n → ℚ) : Function.Injective (centerKey f) := by
  intro i j hij
  have hp := toLex.injective hij
  exact Fin.ext (congrArg Prod.snd hp)

theorem coordinateRank_strict {n : ℕ} {f : Fin n → ℚ} {i j : Fin n}
    (hij : centerKey f i < centerKey f j) : coordinateRank f i < coordinateRank f j := by
  apply Finset.card_lt_card
  apply Finset.ssubset_iff_subset_ne.mpr
  constructor
  · intro k hk
    simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hk ⊢
    exact hk.trans hij
  · intro he
    have hi : i ∈ Finset.univ.filter (fun k => centerKey f k < centerKey f j) := by
      simp [hij]
    rw [← he] at hi
    simp at hi

theorem coordinateRank_lt {n : ℕ} (f : Fin n → ℚ) (i : Fin n) : coordinateRank f i < n := by
  have hs : (Finset.univ.filter fun j => centerKey f j < centerKey f i) ⊂ Finset.univ := by
    apply Finset.ssubset_iff_subset_ne.mpr
    refine ⟨Finset.filter_subset _ _, ?_⟩
    intro he
    have hi : i ∈ Finset.univ.filter (fun j => centerKey f j < centerKey f i) :=
      he.symm ▸ Finset.mem_univ i
    simp at hi
  simpa only [coordinateRank, Finset.card_univ, Fintype.card_fin] using Finset.card_lt_card hs

theorem centerKey_coordinate_le {n : ℕ} {f : Fin n → ℚ} {i j : Fin n}
    (hij : centerKey f i < centerKey f j) : f i ≤ f j :=
  Prod.Lex.monotone_fst _ _ hij.le

def spreadCenter {n : ℕ} (a : Fin n → RationalSpace) (D θ : ℝ) (i : Fin n) : Space :=
  fun j => if j = 0 then (a i 0 : ℝ) + θ * D * coordinateRank (fun q => a q 0) i
    else (a i j : ℝ)

@[simp] theorem spreadCenter_zero {n : ℕ} (a : Fin n → RationalSpace) (D : ℝ) (i : Fin n) :
    spreadCenter a D 0 i = realPoint (a i) := by
  ext j
  by_cases hj : j = 0 <;> simp [spreadCenter, hj, realPoint]

theorem spreadCenter_gap {n : ℕ} (a : Fin n → RationalSpace) {D θ : ℝ}
    (hD : 0 ≤ D) (hθ : 0 ≤ θ) (i j : Fin n) (k : Fin 3) :
    |(a i k : ℝ) - (a j k : ℝ)| ≤ |spreadCenter a D θ i k - spreadCenter a D θ j k| := by
  by_cases hk : k = 0
  · subst k
    wlog hij : centerKey (fun q => a q 0) i ≤ centerKey (fun q => a q 0) j generalizing i j
    · simpa only [abs_sub_comm] using this j i (le_of_not_ge hij)
    rcases hij.eq_or_lt with he | hij
    · have heij := centerKey_injective (fun q => a q 0) he
      subst j
      simp
    have hr : coordinateRank (fun q => a q 0) i ≤ coordinateRank (fun q => a q 0) j :=
      (coordinateRank_strict hij).le
    have hc : (a i 0 : ℝ) ≤ (a j 0 : ℝ) := by exact_mod_cast centerKey_coordinate_le hij
    have hr' : (coordinateRank (fun q => a q 0) i : ℝ) ≤
        (coordinateRank (fun q => a q 0) j : ℝ) := by exact_mod_cast hr
    have hm := mul_le_mul_of_nonneg_left hr' (mul_nonneg hθ hD)
    simp only [spreadCenter, ite_true]
    rw [abs_of_nonpos (sub_nonpos.mpr hc), abs_of_nonpos (by linarith)]
    linarith
  · simp only [spreadCenter, ite_eq_right hk]
    exact le_rfl

theorem spreadCenter_separated {n : ℕ} (a : Fin n → RationalSpace) {D : ℝ}
    (hD : 0 ≤ D) {i j : Fin n} (hij : i ≠ j) :
    D ≤ |spreadCenter a D 1 i 0 - spreadCenter a D 1 j 0| := by
  wlog hkey : centerKey (fun q => a q 0) i < centerKey (fun q => a q 0) j generalizing i j
  · have hne : centerKey (fun q => a q 0) i ≠ centerKey (fun q => a q 0) j :=
      (centerKey_injective (fun q => a q 0)).ne hij
    simpa only [abs_sub_comm] using this hij.symm (lt_of_le_of_ne (le_of_not_gt hkey) hne.symm)
  have hr : coordinateRank (fun q => a q 0) i + 1 ≤ coordinateRank (fun q => a q 0) j :=
    coordinateRank_strict hkey
  have hr' : (coordinateRank (fun q => a q 0) i : ℝ) + 1 ≤
      (coordinateRank (fun q => a q 0) j : ℝ) := by exact_mod_cast hr
  have hc : (a i 0 : ℝ) ≤ (a j 0 : ℝ) := by exact_mod_cast centerKey_coordinate_le hkey
  simp only [spreadCenter, ite_true, one_mul]
  have ha := neg_le_abs ((a i 0 : ℝ) + D * coordinateRank (fun q => a q 0) i -
    ((a j 0 : ℝ) + D * coordinateRank (fun q => a q 0) j))
  nlinarith

theorem spreadCenter_disjoint {n : ℕ} (a : Fin n → RationalSpace) (r : Fin n → Space)
    {D θ : ℝ} (hD : 0 ≤ D) (hθ : 0 ≤ θ) (hr : ∀ i k, 0 ≤ r i k)
    (hsep : Pairwise fun i j => Disjoint (realBox (realPoint (a i)) (r i))
      (realBox (realPoint (a j)) (r j))) :
    Pairwise fun i j => Disjoint (realBox (spreadCenter a D θ i) (r i))
      (realBox (spreadCenter a D θ j) (r j)) := by
  intro i j hij
  obtain ⟨k, hk⟩ := (realBox_disjoint_iff (hr i) (hr j)).mp (hsep hij)
  apply realBox_disjoint_of_gap
  exact ⟨k, hk.trans_le (spreadCenter_gap a hD hθ i j k)⟩

noncomputable def stageSwitch (j : Fin 5) (t : ℝ) : ℝ :=
  Real.smoothTransition (10 * t - 5 / 2 - (j : ℝ))

theorem contDiff_stageSwitch (j : Fin 5) : ContDiff ℝ ∞ (stageSwitch j) := by
  apply Real.smoothTransition.contDiff.comp
  fun_prop

theorem stageSwitch_mem (j : Fin 5) (t : ℝ) : stageSwitch j t ∈ Set.Icc (0 : ℝ) 1 :=
  ⟨Real.smoothTransition.nonneg _, Real.smoothTransition.le_one _⟩

theorem stageSwitch_zero {j : Fin 5} {t : ℝ} (h : 10 * t - 5 / 2 ≤ (j : ℝ)) :
    stageSwitch j t = 0 :=
  Real.smoothTransition.zero_of_nonpos (sub_nonpos.mpr h)

theorem stageSwitch_one {j : Fin 5} {t : ℝ} (h : (j : ℝ) + 1 ≤ 10 * t - 5 / 2) :
    stageSwitch j t = 1 :=
  Real.smoothTransition.one_of_one_le (by linarith)

theorem stageSwitch_before (j : Fin 5) {t : ℝ} (h : t ≤ 1 / 4) : stageSwitch j t = 0 := by
  apply stageSwitch_zero
  have hj : (0 : ℝ) ≤ (j : ℝ) := by positivity
  linarith

theorem stageSwitch_after (j : Fin 5) {t : ℝ} (h : 3 / 4 ≤ t) : stageSwitch j t = 1 := by
  apply stageSwitch_one
  have hj : (j : ℝ) ≤ 4 := by exact_mod_cast Nat.le_of_lt_succ j.isLt
  linarith

theorem stageSwitch_cases (t : ℝ) :
    (stageSwitch 1 t = 0 ∧ stageSwitch 2 t = 0 ∧ stageSwitch 3 t = 0 ∧ stageSwitch 4 t = 0) ∨
    (stageSwitch 0 t = 1 ∧ stageSwitch 2 t = 0 ∧ stageSwitch 3 t = 0 ∧ stageSwitch 4 t = 0) ∨
    (stageSwitch 0 t = 1 ∧ stageSwitch 1 t = 1 ∧ stageSwitch 3 t = 0 ∧ stageSwitch 4 t = 0) ∨
    (stageSwitch 0 t = 1 ∧ stageSwitch 1 t = 1 ∧ stageSwitch 2 t = 1 ∧ stageSwitch 4 t = 0) ∨
    (stageSwitch 0 t = 1 ∧ stageSwitch 1 t = 1 ∧ stageSwitch 2 t = 1 ∧ stageSwitch 3 t = 1) := by
  by_cases h₁ : 10 * t - 5 / 2 ≤ 1
  · exact Or.inl ⟨stageSwitch_zero (by simpa using h₁), stageSwitch_zero (by norm_num; linarith),
      stageSwitch_zero (by norm_num; linarith), stageSwitch_zero (by norm_num; linarith)⟩
  right
  by_cases h₂ : 10 * t - 5 / 2 ≤ 2
  · exact Or.inl ⟨stageSwitch_one (by norm_num; linarith), stageSwitch_zero (by simpa using h₂),
      stageSwitch_zero (by norm_num; linarith), stageSwitch_zero (by norm_num; linarith)⟩
  right
  by_cases h₃ : 10 * t - 5 / 2 ≤ 3
  · exact Or.inl ⟨stageSwitch_one (by norm_num; linarith), stageSwitch_one (by norm_num; linarith),
      stageSwitch_zero (by simpa using h₃), stageSwitch_zero (by norm_num; linarith)⟩
  right
  by_cases h₄ : 10 * t - 5 / 2 ≤ 4
  · exact Or.inl ⟨stageSwitch_one (by norm_num; linarith), stageSwitch_one (by norm_num; linarith),
      stageSwitch_one (by norm_num; linarith), stageSwitch_zero (by simpa using h₄)⟩
  right
  exact ⟨stageSwitch_one (by norm_num; linarith), stageSwitch_one (by norm_num; linarith),
    stageSwitch_one (by norm_num; linarith), stageSwitch_one (by norm_num; linarith)⟩

def routeCenterParameters {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    (u : Fin 5 → ℝ) (i : Fin n) : Space :=
  ![(a i 0 : ℝ) + u 0 * D * coordinateRank (fun q => a q 0) i +
      u 2 * ((b i 0 : ℝ) + D * coordinateRank (fun q => b q 0) i -
        (a i 0 : ℝ) - D * coordinateRank (fun q => a q 0) i) -
      u 4 * D * coordinateRank (fun q => b q 0) i,
    (a i 1 : ℝ) + u 2 * ((b i 1 : ℝ) - (a i 1 : ℝ)),
    (a i 2 : ℝ) + u 1 * (D * (i : ℝ) - (a i 2 : ℝ)) +
      u 3 * ((b i 2 : ℝ) - D * (i : ℝ))]

noncomputable def routeCenters {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    (i : Fin n) (t : ℝ) : Space := routeCenterParameters a b D (fun j => stageSwitch j t) i

theorem contDiff_routeCenters {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ) (i : Fin n) :
    ContDiff ℝ ∞ (routeCenters a b D i) := by
  have hs := contDiff_stageSwitch
  apply contDiff_pi.mpr
  intro j
  fin_cases j <;> dsimp [routeCenters, routeCenterParameters] <;> fun_prop

theorem routeCenter_stage₀ {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    {u : Fin 5 → ℝ} (h₁ : u 1 = 0) (h₂ : u 2 = 0) (h₃ : u 3 = 0) (h₄ : u 4 = 0)
    (i : Fin n) : routeCenterParameters a b D u i = spreadCenter a D (u 0) i := by
  ext j
  fin_cases j <;> simp [routeCenterParameters, spreadCenter, h₁, h₂, h₃, h₄]

theorem routeCenter_stage₁ {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    {u : Fin 5 → ℝ} (h₀ : u 0 = 1) (h₂ : u 2 = 0) (_h₃ : u 3 = 0) (h₄ : u 4 = 0)
    (i : Fin n) : routeCenterParameters a b D u i 0 = spreadCenter a D 1 i 0 := by
  simp [routeCenterParameters, spreadCenter, h₀, h₂, h₄]

theorem routeCenter_stage₂ {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    {u : Fin 5 → ℝ} (_h₀ : u 0 = 1) (h₁ : u 1 = 1) (h₃ : u 3 = 0) (_h₄ : u 4 = 0)
    (i : Fin n) : routeCenterParameters a b D u i 2 = D * (i : ℝ) := by
  simp [routeCenterParameters, h₁, h₃]

theorem routeCenter_stage₃ {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    {u : Fin 5 → ℝ} (h₀ : u 0 = 1) (_h₁ : u 1 = 1) (h₂ : u 2 = 1) (h₄ : u 4 = 0)
    (i : Fin n) : routeCenterParameters a b D u i 0 = spreadCenter b D 1 i 0 := by
  simp [routeCenterParameters, spreadCenter, h₀, h₂, h₄]

theorem routeCenter_stage₄ {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    {u : Fin 5 → ℝ} (h₀ : u 0 = 1) (h₁ : u 1 = 1) (h₂ : u 2 = 1) (h₃ : u 3 = 1)
    (i : Fin n) : routeCenterParameters a b D u i = spreadCenter b D (1 - u 4) i := by
  ext j
  fin_cases j <;> simp [routeCenterParameters, spreadCenter, h₀, h₁, h₂, h₃]
  ring

theorem routeCenters_before {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    (i : Fin n) {t : ℝ} (ht : t ≤ 1 / 4) : routeCenters a b D i t = realPoint (a i) := by
  rw [routeCenters, routeCenter_stage₀ a b D
    (stageSwitch_before 1 ht) (stageSwitch_before 2 ht) (stageSwitch_before 3 ht)
    (stageSwitch_before 4 ht), stageSwitch_before 0 ht, spreadCenter_zero]

theorem routeCenters_after {n : ℕ} (a b : Fin n → RationalSpace) (D : ℝ)
    (i : Fin n) {t : ℝ} (ht : 3 / 4 ≤ t) : routeCenters a b D i t = realPoint (b i) := by
  rw [routeCenters, routeCenter_stage₄ a b D
    (stageSwitch_after 0 ht) (stageSwitch_after 1 ht) (stageSwitch_after 2 ht)
    (stageSwitch_after 3 ht), stageSwitch_after 4 ht, sub_self, spreadCenter_zero]

theorem private_layers_separated {n : ℕ} {D : ℝ} (hD : 0 ≤ D) {i j : Fin n} (hij : i ≠ j) :
    D ≤ |D * (i : ℝ) - D * (j : ℝ)| := by
  wlog hlt : i < j generalizing i j
  · simpa only [abs_sub_comm] using this hij.symm (lt_of_le_of_ne (le_of_not_gt hlt) hij.symm)
  have hstep : (i : ℝ) + 1 ≤ (j : ℝ) := by exact_mod_cast hlt
  have ha := neg_le_abs (D * (i : ℝ) - D * (j : ℝ))
  nlinarith

def scaleRatio {n : ℕ} (h k : Fin n → RationalSpace) (i : Fin n) (j : Fin 3) : ℝ :=
  ((k i j / h i j : ℚ) : ℝ)

noncomputable def balancedScale (s : Space) (u : ℝ) : Space :=
  ![1 - u + u * s 0, 1 - u + u * s 1,
    ((1 - u + u * s 0) * (1 - u + u * s 1))⁻¹]

@[simp] theorem balancedScale_zero (s : Space) : balancedScale s 0 = 1 := by
  ext j; fin_cases j <;> simp [balancedScale]

theorem balancedScale_one (s : Space) (hdet : ∏ j : Fin 3, s j = 1) :
    balancedScale s 1 = s := by
  have hd : s 0 * s 1 * s 2 = 1 := by simpa [Fin.prod_univ_three] using hdet
  ext j
  fin_cases j
  · simp [balancedScale]
  · simp [balancedScale]
  · simpa [balancedScale] using inv_eq_of_mul_eq_one_right hd

theorem linearBlend_between {s u : ℝ} (hu : u ∈ Set.Icc (0 : ℝ) 1) :
    min 1 s ≤ 1 - u + u * s ∧ 1 - u + u * s ≤ max 1 s := by
  by_cases h : 1 ≤ s
  · rw [min_eq_left h, max_eq_right h]
    constructor
    · nlinarith [mul_nonneg hu.1 (sub_nonneg.mpr h)]
    · nlinarith [mul_nonneg (sub_nonneg.mpr hu.2) (sub_nonneg.mpr h)]
  · have h' := le_of_not_ge h
    rw [min_eq_right h', max_eq_left h']
    constructor
    · nlinarith [mul_nonneg (sub_nonneg.mpr hu.2) (sub_nonneg.mpr h')]
    · nlinarith [mul_nonneg hu.1 (sub_nonneg.mpr h')]

theorem linearBlend_pos {s u : ℝ} (hs : 0 < s) (hu : u ∈ Set.Icc (0 : ℝ) 1) :
    0 < 1 - u + u * s :=
  lt_of_lt_of_le (lt_min zero_lt_one hs) (linearBlend_between hu).1

theorem linearBlend_product_lower {s t u : ℝ} (hs : 0 < s) (ht : 0 < t)
    (hu : u ∈ Set.Icc (0 : ℝ) 1) :
    min 1 (s * t) ≤ (1 - u + u * s) * (1 - u + u * t) := by
  have hb (s : ℝ) := linearBlend_between (s := s) hu
  have hbs : 0 ≤ 1 - u + u * s := (linearBlend_pos hs hu).le
  have hbt : 0 ≤ 1 - u + u * t := (linearBlend_pos ht hu).le
  by_cases hs' : 1 ≤ s <;> by_cases ht' : 1 ≤ t
  · have h₁ : 1 ≤ 1 - u + u * s := by simpa [min_eq_left hs'] using (hb s).1
    have h₂ : 1 ≤ 1 - u + u * t := by simpa [min_eq_left ht'] using (hb t).1
    exact (min_le_left _ _).trans (by nlinarith)
  · have hc : 0 ≤ u * (1 - u) * (s - 1) * (1 - t) :=
      mul_nonneg (mul_nonneg (mul_nonneg hu.1 (sub_nonneg.mpr hu.2))
        (sub_nonneg.mpr hs')) (sub_nonneg.mpr (le_of_not_ge ht'))
    have hl := (linearBlend_between (s := s * t) hu).1
    nlinarith
  · have hc : 0 ≤ u * (1 - u) * (1 - s) * (t - 1) :=
      mul_nonneg (mul_nonneg (mul_nonneg hu.1 (sub_nonneg.mpr hu.2))
        (sub_nonneg.mpr (le_of_not_ge hs'))) (sub_nonneg.mpr ht')
    have hl := (linearBlend_between (s := s * t) hu).1
    nlinarith
  · have h₁ : s ≤ 1 - u + u * s := by simpa [min_eq_right (le_of_not_ge hs')] using (hb s).1
    have h₂ : t ≤ 1 - u + u * t := by simpa [min_eq_right (le_of_not_ge ht')] using (hb t).1
    exact (min_le_right _ _).trans (mul_le_mul h₁ h₂ ht.le hbs)

theorem balancedScale_pos (s : Space) (hs : ∀ j, 0 < s j)
    {u : ℝ} (hu : u ∈ Set.Icc (0 : ℝ) 1) (j : Fin 3) :
    0 < balancedScale s u j := by
  fin_cases j
  · exact linearBlend_pos (hs 0) hu
  · exact linearBlend_pos (hs 1) hu
  · exact inv_pos.mpr (mul_pos (linearBlend_pos (hs 0) hu) (linearBlend_pos (hs 1) hu))

theorem balancedScale_det (s : Space) (hs : ∀ j, 0 < s j)
    {u : ℝ} (hu : u ∈ Set.Icc (0 : ℝ) 1) : ∏ j : Fin 3, balancedScale s u j = 1 := by
  simp only [Fin.prod_univ_three, balancedScale, Matrix.cons_val_zero, Matrix.cons_val_one,
    Matrix.cons_val_two]
  exact mul_inv_cancel₀ (mul_ne_zero (ne_of_gt (linearBlend_pos (hs 0) hu))
    (ne_of_gt (linearBlend_pos (hs 1) hu)))

theorem balancedScale_le (s : Space) (hs : ∀ j, 0 < s j)
    (hdet : ∏ j : Fin 3, s j = 1) {u : ℝ} (hu : u ∈ Set.Icc (0 : ℝ) 1) (j : Fin 3) :
    balancedScale s u j ≤ max 1 (s j) := by
  fin_cases j
  · exact (linearBlend_between hu).2
  · exact (linearBlend_between hu).2
  have hp := linearBlend_product_lower (hs 0) (hs 1) hu
  have hd : (s 0 * s 1)⁻¹ = s 2 := by
    exact inv_eq_of_mul_eq_one_right (by simpa [Fin.prod_univ_three] using hdet)
  change ((1 - u + u * s 0) * (1 - u + u * s 1))⁻¹ ≤ max 1 (s 2)
  by_cases he : 1 ≤ s 0 * s 1
  · rw [min_eq_left he] at hp
    apply le_trans _ (le_max_left _ _)
    exact inv_le_one_of_one_le₀ hp
  · rw [min_eq_right (le_of_not_ge he)] at hp
    apply le_trans _ (le_max_right _ _)
    rw [← hd]
    exact inv_anti₀ (mul_pos (hs 0) (hs 1)) hp

noncomputable def routeScales {n : ℕ} (h k : Fin n → RationalSpace) (i : Fin n) (t : ℝ) : Space :=
  balancedScale (scaleRatio h k i) (stageSwitch 2 t)

theorem scaleRatio_pos {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) (j : Fin 3) :
    0 < scaleRatio h k i j := by
  unfold scaleRatio
  exact_mod_cast div_pos (hk i j) (hh i j)

theorem scaleRatio_mul_width {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (i : Fin n) (j : Fin 3) :
    scaleRatio h k i j * (h i j : ℝ) = (k i j : ℝ) := by
  unfold scaleRatio
  exact_mod_cast div_mul_cancel₀ (k i j) (ne_of_gt (hh i j))

theorem contDiff_routeScales {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) :
    ContDiff ℝ ∞ (routeScales h k i) := by
  have hp (j : Fin 3) (t : ℝ) := linearBlend_pos (scaleRatio_pos hh hk i j) (stageSwitch_mem 2 t)
  apply contDiff_pi.mpr
  intro j
  fin_cases j
  · change ContDiff ℝ ∞ (fun t => 1 - stageSwitch 2 t + stageSwitch 2 t * scaleRatio h k i 0)
    exact (contDiff_const.sub (contDiff_stageSwitch 2)).add ((contDiff_stageSwitch 2).mul contDiff_const)
  · change ContDiff ℝ ∞ (fun t => 1 - stageSwitch 2 t + stageSwitch 2 t * scaleRatio h k i 1)
    exact (contDiff_const.sub (contDiff_stageSwitch 2)).add ((contDiff_stageSwitch 2).mul contDiff_const)
  · change ContDiff ℝ ∞ (fun t => ((1 - stageSwitch 2 t + stageSwitch 2 t * scaleRatio h k i 0) *
        (1 - stageSwitch 2 t + stageSwitch 2 t * scaleRatio h k i 1))⁻¹)
    apply ContDiff.inv
    · exact ((contDiff_const.sub (contDiff_stageSwitch 2)).add ((contDiff_stageSwitch 2).mul contDiff_const)).mul
        ((contDiff_const.sub (contDiff_stageSwitch 2)).add ((contDiff_stageSwitch 2).mul contDiff_const))
    · intro t; exact ne_of_gt (mul_pos (hp 0 t) (hp 1 t))

theorem routeScales_pos {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j) (i : Fin n) (t : ℝ) (j : Fin 3) :
    0 < routeScales h k i t j :=
  balancedScale_pos _ (scaleRatio_pos hh hk i) (stageSwitch_mem 2 t) j

theorem routeScales_det {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (_hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1) (i : Fin n) (t : ℝ) :
    ∏ j : Fin 3, routeScales h k i t j = 1 :=
  balancedScale_det _ (scaleRatio_pos hh hk i) (stageSwitch_mem 2 t)

theorem scaleRatio_det {n : ℕ} {h k : Fin n → RationalSpace}
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1) (i : Fin n) :
    ∏ j : Fin 3, scaleRatio h k i j = 1 := by
  unfold scaleRatio
  exact_mod_cast hvol i

theorem routeScales_le {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1)
    {M : ℝ} (hM : 1 ≤ M) (hsM : ∀ i j, scaleRatio h k i j ≤ M)
    (i : Fin n) (t : ℝ) (j : Fin 3) : routeScales h k i t j ≤ M :=
  (balancedScale_le _ (scaleRatio_pos hh hk i) (scaleRatio_det hvol i) (stageSwitch_mem 2 t) j).trans
    (max_le hM (hsM i j))

theorem routeScales_before {n : ℕ} (h k : Fin n → RationalSpace)
    (i : Fin n) {t : ℝ} (ht : t ≤ 1 / 4) : routeScales h k i t = 1 := by
  simp [routeScales, stageSwitch_before 2 ht]

theorem routeScales_after {n : ℕ} (h k : Fin n → RationalSpace)
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1)
    (i : Fin n) {t : ℝ} (ht : 3 / 4 ≤ t) : routeScales h k i t = scaleRatio h k i := by
  simp only [routeScales, stageSwitch_after 2 ht, balancedScale_one _ (scaleRatio_det hvol i)]

theorem routeScales_width_le {n : ℕ} {h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1)
    {R : ℝ} (hhR : ∀ i j, (h i j : ℝ) ≤ R) (hkR : ∀ i j, (k i j : ℝ) ≤ R)
    (i : Fin n) (t : ℝ) (j : Fin 3) : routeScales h k i t j * (h i j : ℝ) ≤ R := by
  have hh' : 0 ≤ (h i j : ℝ) := by exact_mod_cast (hh i j).le
  have hs := balancedScale_le _ (scaleRatio_pos hh hk i) (scaleRatio_det hvol i) (stageSwitch_mem 2 t) j
  apply (mul_le_mul_of_nonneg_right hs hh').trans
  rw [max_mul_of_nonneg _ _ hh', one_mul, scaleRatio_mul_width hh]
  exact max_le (hhR i j) (hkR i j)

def boxDataBound {n : ℕ} (h k : Fin n → RationalSpace) : ℚ :=
  1 + ∑ i : Fin n, ∑ j : Fin 3, (|h i j| + |k i j| + |k i j / h i j| + 1)

theorem boxDataBound_ge_one {n : ℕ} (h k : Fin n → RationalSpace) : 1 ≤ boxDataBound h k := by
  unfold boxDataBound
  have hn : 0 ≤ ∑ i : Fin n, ∑ j : Fin 3, (|h i j| + |k i j| + |k i j / h i j| + 1) :=
    Finset.sum_nonneg (fun _ _ => Finset.sum_nonneg (fun _ _ => by positivity))
  linarith

theorem boxDataBound_bounds {n : ℕ} (h k : Fin n → RationalSpace) (i : Fin n) (j : Fin 3) :
    h i j ≤ boxDataBound h k ∧ k i j ≤ boxDataBound h k ∧ k i j / h i j ≤ boxDataBound h k := by
  have h₁ : |h i j| + |k i j| + |k i j / h i j| + 1 ≤
      ∑ l : Fin 3, (|h i l| + |k i l| + |k i l / h i l| + 1) :=
    Finset.single_le_sum (f := fun l : Fin 3 => |h i l| + |k i l| + |k i l / h i l| + 1)
      (fun _ _ => by positivity) (Finset.mem_univ j)
  have h₂ : (∑ l : Fin 3, (|h i l| + |k i l| + |k i l / h i l| + 1)) ≤
      ∑ s : Fin n, ∑ l : Fin 3, (|h s l| + |k s l| + |k s l / h s l| + 1) :=
    Finset.single_le_sum (f := fun s : Fin n => ∑ l : Fin 3,
      (|h s l| + |k s l| + |k s l / h s l| + 1))
      (fun _ _ => Finset.sum_nonneg (fun _ _ => by positivity)) (Finset.mem_univ i)
  have hs := h₁.trans h₂
  have hha := le_abs_self (h i j)
  have hka := le_abs_self (k i j)
  have hsa := le_abs_self (k i j / h i j)
  have hhn := abs_nonneg (h i j)
  have hkn := abs_nonneg (k i j)
  have hsn := abs_nonneg (k i j / h i j)
  unfold boxDataBound
  constructor
  · linarith
  constructor <;> linarith

theorem route_padded_disjoint {n : ℕ} {a b h k : Fin n → RationalSpace}
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1)
    {R η : ℝ} (hR : 0 < R) (hη : 0 < η) (hηR : η < R / 8)
    (hhR : ∀ i j, (h i j : ℝ) ≤ R) (hkR : ∀ i j, (k i j : ℝ) ≤ R)
    (ha : Pairwise fun i j =>
      Disjoint (realBox (realPoint (a i)) (fun l => (h i l : ℝ) + 2 * η))
        (realBox (realPoint (a j)) (fun l => (h j l : ℝ) + 2 * η)))
    (hb : Pairwise fun i j =>
      Disjoint (realBox (realPoint (b i)) (fun l => (k i l : ℝ) + 2 * η))
        (realBox (realPoint (b j)) (fun l => (k j l : ℝ) + 2 * η))) (t : ℝ) :
    Pairwise fun i j =>
      Disjoint
        (realBox (routeCenters a b (30 * R) i t)
          (fun l => routeScales h k i t l * (h i l : ℝ) + 2 * η))
        (realBox (routeCenters a b (30 * R) j t)
          (fun l => routeScales h k j t l * (h j l : ℝ) + 2 * η)) := by
  have hD : 0 ≤ 30 * R := by positivity
  have h4 : 4 * R ≤ 30 * R := by linarith
  have hwidth (i : Fin n) (j : Fin 3) := routeScales_width_le hh hk hvol hhR hkR i t j
  rcases stageSwitch_cases t with ⟨h₁, h₂, h₃, h₄⟩ | ⟨h₀, h₂, h₃, h₄⟩ |
    ⟨h₀, h₁, h₃, h₄⟩ | ⟨h₀, h₁, h₂, h₄⟩ | ⟨h₀, h₁, h₂, h₃⟩
  · have hp : ∀ i j, 0 ≤ (h i j : ℝ) + 2 * η := by
      intro i j
      have hhi : (0 : ℝ) < (h i j : ℝ) := by exact_mod_cast hh i j
      linarith
    have hs := spreadCenter_disjoint a (fun i j => (h i j : ℝ) + 2 * η) hD
      (stageSwitch_mem 0 t).1 hp ha
    simpa only [routeCenters, routeCenter_stage₀ a b (30 * R) (u := fun j => stageSwitch j t) h₁ h₂ h₃ h₄,
      routeScales, h₂, balancedScale_zero, Pi.one_apply, one_mul] using hs
  · intro i j hij
    apply padded_boxes_disjoint_of_clearance hR hηR (hwidth i) (hwidth j)
    refine ⟨0, h4.trans ?_⟩
    simpa only [routeCenters, routeCenter_stage₁ a b (30 * R) (u := fun j => stageSwitch j t) h₀ h₂ h₃ h₄] using
      spreadCenter_separated a hD hij
  · intro i j hij
    apply padded_boxes_disjoint_of_clearance hR hηR (hwidth i) (hwidth j)
    refine ⟨2, h4.trans ?_⟩
    simpa only [routeCenters, routeCenter_stage₂ a b (30 * R) (u := fun j => stageSwitch j t) h₀ h₁ h₃ h₄] using
      private_layers_separated hD hij
  · intro i j hij
    apply padded_boxes_disjoint_of_clearance hR hηR (hwidth i) (hwidth j)
    refine ⟨0, h4.trans ?_⟩
    simpa only [routeCenters, routeCenter_stage₃ a b (30 * R) (u := fun j => stageSwitch j t) h₀ h₁ h₂ h₄] using
      spreadCenter_separated b hD hij
  · have hp : ∀ i j, 0 ≤ (k i j : ℝ) + 2 * η := by
      intro i j
      have hki : (0 : ℝ) < (k i j : ℝ) := by exact_mod_cast hk i j
      linarith
    have hs := spreadCenter_disjoint b (fun i j => (k i j : ℝ) + 2 * η) hD
      (by have := (stageSwitch_mem 4 t).2; linarith : 0 ≤ 1 - stageSwitch 4 t) hp hb
    simpa only [routeCenters, routeCenter_stage₄ a b (30 * R) (u := fun j => stageSwitch j t) h₀ h₁ h₂ h₃,
      routeScales, h₂, balancedScale_one _ (scaleRatio_det hvol _), scaleRatio_mul_width hh] using hs

noncomputable def stationaryMotionField {n : ℕ} (c d : Fin n → ℝ → Space)
    (h : Fin n → Space) (η : ℝ) : Field :=
  spatialCurl (familyPotential c (fun i => deriv (c i))
    (fun i => diagonalLogVelocity (d i))
    (fun i t j => d i t j * h i j) η)

theorem finite_motion_bound {n : ℕ} {c r : Fin n → ℝ → Space}
    (hc : ∀ i, Continuous (c i)) (hr : ∀ i, Continuous (r i)) (η t₀ t₁ : ℝ) :
    ∃ R : ℝ, 0 < R ∧ ∀ i t, t ∈ Set.Icc t₀ t₁ → ∀ j,
      |c i t j| + r i t j + 2 * η ≤ R := by
  let F : ℝ → ℝ := fun t => (∑ i : Fin n, (‖c i t‖ + ‖r i t‖)) + 2 * |η|
  have hF : Continuous F := by fun_prop
  obtain ⟨R, hR, hb⟩ := (isCompact_Icc.image hF).isBounded.exists_pos_norm_le
  refine ⟨R, hR, ?_⟩
  intro i t ht j
  have hs : ‖c i t‖ + ‖r i t‖ ≤ ∑ i : Fin n, (‖c i t‖ + ‖r i t‖) :=
    Finset.single_le_sum (f := fun i : Fin n => ‖c i t‖ + ‖r i t‖)
      (fun _ _ => add_nonneg (norm_nonneg _) (norm_nonneg _)) (Finset.mem_univ i)
  have hcn : |c i t j| ≤ ‖c i t‖ := norm_le_pi_norm (c i t) j
  have hrn : r i t j ≤ ‖r i t‖ := (le_abs_self _).trans (norm_le_pi_norm (r i t) j)
  have hη := le_abs_self η
  have hf := le_abs_self (F t)
  have hb' : |F t| ≤ R := hb _ ⟨t, ht, rfl⟩
  dsimp [F] at hf
  linarith

theorem stationaryMotionField_realizes {n : ℕ}
    (a h : Fin n → Space) {c d : Fin n → ℝ → Space}
    {η M : ℝ} (hη : 0 < η) (hM : 0 < M)
    (hc : ∀ i, ContDiff ℝ ∞ (c i)) (hd : ∀ i, ContDiff ℝ ∞ (d i))
    (hstart : ∀ i t, t ≤ (1 / 4 : ℝ) → c i t = a i ∧ d i t = 1)
    (hend : ∀ i t, (3 / 4 : ℝ) ≤ t → c i t = c i 1 ∧ d i t = d i 1)
    (hdet : ∀ i t, ∏ j : Fin 3, d i t j = 1)
    (hdpos : ∀ i t j, 0 < d i t j) (hdM : ∀ i t j, d i t j ≤ M)
    (hdis : ∀ t, Pairwise fun i j =>
      Disjoint (realBox (c i t) (fun k => d i t k * h i k + 2 * η))
        (realBox (c j t) (fun k => d j t k * h j k + 2 * η))) :
    ContDiff ℝ ∞ (stationaryMotionField c d h η) ∧
    HasCompactSupport (stationaryMotionField c d h η) ∧
    (∀ t x, spatialDivergence (stationaryMotionField c d h η) t x = 0) ∧
    (∀ (t : ℝ) x, t ∉ Set.Icc (1 / 4 : ℝ) (3 / 4 : ℝ) →
      stationaryMotionField c d h η (t, x) = 0) ∧
    ∃ Φ, IsGlobalFlow (stationaryMotionField c d h η) Φ ∧
      (∀ i, ∃ O : Set Space, IsOpen O ∧ realBox (a i) (h i) ⊆ O ∧
        ∀ x ∈ O, ∀ t, Φ t x = affineTrajectory (c i) (d i) (a i) x t) := by
  let r : Fin n → ℝ → Space := fun i t j => d i t j * h i j
  let v : Fin n → ℝ → Space := fun i => deriv (c i)
  let l : Fin n → ℝ → Space := fun i => diagonalLogVelocity (d i)
  have hv (i : Fin n) : ContDiff ℝ ∞ (v i) := contDiff_motion_deriv (hc i)
  have hl (i : Fin n) : ContDiff ℝ ∞ (l i) := contDiff_diagonalLogVelocity (hd i) (hdpos i)
  have hr (i : Fin n) : ContDiff ℝ ∞ (r i) := by
    apply contDiff_pi.mpr
    intro j
    exact (contDiff_pi.mp (hd i) j).mul contDiff_const
  have htr (i : Fin n) (t : ℝ) : ∑ j : Fin 3, l i t j = 0 :=
    trace_zero_of_determinant_one (hasDerivAt_diagonalLogVelocity (hd i) (hdpos i) t) (hdet i)
  have htime : ∀ i t, t ∉ Set.Icc (1 / 4 : ℝ) (3 / 4 : ℝ) → v i t = 0 ∧ l i t = 0 := by
    intro i t ht
    refine ⟨deriv_zero_outside_interval (fun s hs => (hstart i s hs).1)
      (fun s hs => (hend i s hs).1) ht, ?_⟩
    have hz := deriv_zero_outside_interval (fun s hs => (hstart i s hs).2)
      (fun s hs => (hend i s hs).2) ht
    ext j
    simp [l, diagonalLogVelocity, hz]
  obtain ⟨R, hR, hbound⟩ := finite_motion_bound (fun i => (hc i).continuous)
    (fun i => (hr i).continuous) η (1 / 4) (3 / 4)
  have hA := contDiff_familyPotential η hc hv hl hr
  have hcp := hasCompactSupport_familyPotential hη hR.le hbound htime
  have hzero : ∀ (t : ℝ) x, t ∉ Set.Icc (1 / 4 : ℝ) (3 / 4 : ℝ) →
      familyPotential c v l r η (t, x) = 0 := by
    intro t x ht
    exact familyPotential_zero η (fun i => (htime i t ht).1) (fun i => (htime i t ht).2) x
  obtain ⟨hUsm, hUcp, hUdiv, hUt⟩ := curl_field_properties hA hcp hzero
  refine ⟨hUsm, hUcp, hUdiv, hUt, ?_⟩
  obtain ⟨Φ, hΦ⟩ := smooth_compact_globalFlow hUsm hUcp
  refine ⟨Φ, hΦ, ?_⟩
  intro i
  have hδ : 0 < η / (2 * M) := div_pos hη (by positivity)
  refine ⟨openBox (a i) (h i) (η / (2 * M)), isOpen_openBox _ _ _,
    realBox_subset_openBox _ _ hδ, ?_⟩
  intro x hx t
  apply Eq.symm
  apply hΦ.2.2 x (affineTrajectory (c i) (d i) (a i) x)
    (affineTrajectory_initial (hstart i 0 (by norm_num)).1 (hstart i 0 (by norm_num)).2 x)
  intro s
  have hp := affineTrajectory_in_plateau (c := c i) (a i) (h i) hη hM (hdpos i) (hdM i) hx s
  rw [spatialCurl_familyPotential_on_plateau hη hc hv hl hr htr hdis i hp]
  exact hasDerivAt_affineTrajectory ((hc i).differentiable (by simp) s).hasDerivAt
    (hasDerivAt_diagonalLogVelocity (hd i) (hdpos i) s) (a i) x

noncomputable def routedField {n : ℕ} (a b h k : Fin n → RationalSpace) (η : ℚ) : Field :=
  stationaryMotionField (routeCenters a b (30 * (boxDataBound h k : ℝ)))
    (routeScales h k) (fun i => realPoint (h i)) η

theorem routedField_realizes {n : ℕ} (a b h k : Fin n → RationalSpace)
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1)
    {η : ℚ} (hη : 0 < η) (hηR : η < boxDataBound h k / 8)
    (ha : Pairwise fun i j =>
      Disjoint (realBox (realPoint (a i)) (fun l => (h i l : ℝ) + 2 * η))
        (realBox (realPoint (a j)) (fun l => (h j l : ℝ) + 2 * η)))
    (hb : Pairwise fun i j =>
      Disjoint (realBox (realPoint (b i)) (fun l => (k i l : ℝ) + 2 * η))
        (realBox (realPoint (b j)) (fun l => (k j l : ℝ) + 2 * η))) :
    ContDiff ℝ ∞ (routedField a b h k η) ∧ HasCompactSupport (routedField a b h k η) ∧
    (∀ t x, spatialDivergence (routedField a b h k η) t x = 0) ∧
    (∀ (t : ℝ) x, t ∉ Set.Icc (1 / 4 : ℝ) (3 / 4 : ℝ) → routedField a b h k η (t, x) = 0) ∧
    ∃ Φ, IsGlobalFlow (routedField a b h k η) Φ ∧ Delivers a b h k Φ := by
  let R : ℝ := boxDataBound h k
  have hR₁ : 1 ≤ R := by dsimp [R]; exact_mod_cast boxDataBound_ge_one h k
  have hR : 0 < R := lt_of_lt_of_le zero_lt_one hR₁
  have hη' : (0 : ℝ) < η := by exact_mod_cast hη
  have hηR' : (η : ℝ) < R / 8 := by dsimp [R]; exact_mod_cast hηR
  have hbound (i : Fin n) (j : Fin 3) :
      (h i j : ℝ) ≤ R ∧ (k i j : ℝ) ≤ R ∧ scaleRatio h k i j ≤ R := by
    dsimp [R, scaleRatio]
    exact_mod_cast boxDataBound_bounds h k i j
  have hstart (i : Fin n) (t : ℝ) (ht : t ≤ (1 / 4 : ℝ)) :
      routeCenters a b (30 * R) i t = realPoint (a i) ∧ routeScales h k i t = 1 :=
    ⟨routeCenters_before a b (30 * R) i ht, routeScales_before h k i ht⟩
  have hend (i : Fin n) (t : ℝ) (ht : (3 / 4 : ℝ) ≤ t) :
      routeCenters a b (30 * R) i t = routeCenters a b (30 * R) i 1 ∧
      routeScales h k i t = routeScales h k i 1 := by
    rw [routeCenters_after a b (30 * R) i ht, routeCenters_after a b (30 * R) i (t := 1) (by norm_num),
      routeScales_after h k hvol i ht, routeScales_after h k hvol i (t := 1) (by norm_num)]
    exact ⟨rfl, rfl⟩
  have hsep := route_padded_disjoint hh hk hvol hR hη' hηR'
    (fun i j => (hbound i j).1) (fun i j => (hbound i j).2.1) ha hb
  obtain ⟨hsm, hcp, hdiv, htime, Φ, hΦ, hn⟩ :=
    stationaryMotionField_realizes (fun i => realPoint (a i)) (fun i => realPoint (h i))
      hη' hR (contDiff_routeCenters a b (30 * R)) (contDiff_routeScales hh hk)
      hstart hend (routeScales_det hh hk hvol) (routeScales_pos hh hk)
      (routeScales_le hh hk hvol hR₁ (fun i j => (hbound i j).2.2)) hsep
  refine ⟨hsm, hcp, hdiv, htime, Φ, hΦ, ?_⟩
  intro i
  obtain ⟨O, hO, hbO, hmap⟩ := hn i
  refine ⟨O, hO, hbO, ?_⟩
  intro x hx
  rw [hmap x hx 1]
  ext j
  simp only [affineTrajectory, routeCenters_after a b (30 * R) i (t := 1) (by norm_num),
    routeScales_after h k hvol i (t := 1) (by norm_num), scaleRatio, realPoint, prescribedAffine]

theorem exists_routedField_realization
    (n : ℕ) (a b h k : Fin n → RationalSpace)
    (hh : ∀ i j, 0 < h i j) (hk : ∀ i j, 0 < k i j)
    (ha : Pairwise fun i j => Disjoint (solidBox (a i) (h i)) (solidBox (a j) (h j)))
    (hb : Pairwise fun i j => Disjoint (solidBox (b i) (k i)) (solidBox (b j) (k j)))
    (hvol : ∀ i, ∏ j : Fin 3, k i j / h i j = 1) :
    ∃ η : ℚ, 0 < η ∧
      ContDiff ℝ ∞ (routedField a b h k η) ∧ HasCompactSupport (routedField a b h k η) ∧
      (∀ t x, spatialDivergence (routedField a b h k η) t x = 0) ∧
      (∀ (t : ℝ) x, t ∉ Set.Icc (1 / 4 : ℝ) (3 / 4 : ℝ) → routedField a b h k η (t, x) = 0) ∧
      ∃ Φ, IsGlobalFlow (routedField a b h k η) Φ ∧ Delivers a b h k Φ := by
  have hR : 0 < boxDataBound h k := lt_of_lt_of_le zero_lt_one (boxDataBound_ge_one h k)
  obtain ⟨η, hη, hηR, hap, hbp⟩ := exists_rational_padding a b h k
    (fun i j => (hh i j).le) (fun i j => (hk i j).le) ha hb (boxDataBound h k) hR
  exact ⟨η, hη, routedField_realizes a b h k hh hk hvol hη hηR hap hbp⟩
end BoxTransport.Routing

end

end OAI