import Mathlib
import OAI.Geometry.RecorderBoxes.Branches

namespace OAI

/-! Separated state-square placement of recorder controls. -/

namespace Solenoidal
namespace Bridge
variable {M : Machine}
def terminalControl : Recorder.Control M → Bool
  | .S q => M.halt q
  | _ => false

abbrev controlCount (M : Machine) : ℕ := Fintype.card (Recorder.Control M)

 

noncomputable def controlIndex (M : Machine) : Recorder.Control M ≃ Fin (controlCount M) :=
  Fintype.equivFin _

theorem controlCount_pos (M : Machine) : 0 < controlCount M :=
  Fintype.card_pos_iff.mpr ⟨.S M.initial⟩

noncomputable def kappa (M : Machine) : ℝ := 1 / (32 * (controlCount M : ℝ))

theorem kappa_pos (M : Machine) : 0 < kappa M :=
  one_div_pos.mpr (mul_pos (by norm_num) (by exact_mod_cast controlCount_pos M))

theorem kappa_le (M : Machine) : kappa M ≤ 1 / 32 := by
  apply one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 32)
  have hN : (1 : ℝ) ≤ controlCount M := by exact_mod_cast controlCount_pos M
  nlinarith

noncomputable def origin (s : Recorder.Control M) : ℝ :=
  (if terminalControl s then 3 / 4 else 1 / 8) +
    2 * ((controlIndex M s).val : ℝ) * kappa M

 
theorem state_extent (s : Recorder.Control M) :
    (if terminalControl s then (3 / 4 : ℝ) else 1 / 8) ≤ origin s ∧
    origin s + kappa M < (if terminalControl s then (13 / 16 : ℝ) else 3 / 16) := by
  have hk := kappa_pos M
  have h₀ : (0 : ℝ) ≤ (controlIndex M s).val := Nat.cast_nonneg _
  have hN : (↑(controlIndex M s).val : ℝ) + 1 ≤ controlCount M := by
    exact_mod_cast (controlIndex M s).isLt
  have hprod : 2 * (controlCount M : ℝ) * kappa M = 1 / 16 := by
    dsimp only [kappa]
    have hn : (controlCount M : ℝ) ≠ 0 := by
      exact_mod_cast (controlCount_pos M).ne'
    field_simp
    norm_num
  have hscaled := mul_le_mul_of_nonneg_right hN hk.le
  have hnonneg := mul_nonneg h₀ hk.le
  dsimp only [origin]
  cases terminalControl s <;> simp only [Bool.false_eq_true, ↓reduceIte] <;>
    constructor <;> nlinarith

 
theorem state_gap {s t : Recorder.Control M} (hne : s ≠ t) :
    (origin s + kappa M) + kappa M ≤ origin t ∨
    (origin t + kappa M) + kappa M ≤ origin s := by
  have hk := kappa_pos M
  by_cases he : terminalControl s = terminalControl t
  · have hidx : (controlIndex M s).val ≠ (controlIndex M t).val := by
      intro hi
      exact hne ((controlIndex M).injective (Fin.ext hi))
    rcases lt_or_gt_of_ne hidx with hi | hi
    · left
      have hi' : (↑(controlIndex M s).val : ℝ) + 1 ≤ (controlIndex M t).val := by
        exact_mod_cast hi
      have hm := mul_le_mul_of_nonneg_right hi' hk.le
      dsimp only [origin]
      rw [he]
      nlinarith
    · right
      have hi' : (↑(controlIndex M t).val : ℝ) + 1 ≤ (controlIndex M s).val := by
        exact_mod_cast hi
      have hm := mul_le_mul_of_nonneg_right hi' hk.le
      dsimp only [origin]
      rw [he]
      nlinarith
  · have hs := state_extent s
    have ht := state_extent t
    have hκ := kappa_le M
    cases es : terminalControl s <;> cases et : terminalControl t
    · exact False.elim (he (es.trans et.symm))
    · simp only [es, Bool.false_eq_true, ↓reduceIte] at hs
      simp only [et, ↓reduceIte] at ht
      left; linarith
    · simp only [es, ↓reduceIte] at hs
      simp only [et, Bool.false_eq_true, ↓reduceIte] at ht
      right; linarith
    · exact False.elim (he (es.trans et.symm))

 
noncomputable def place (s : Recorder.Control M) (p : ℝ × ℝ) : ℝ × ℝ :=
  (origin s + kappa M * p.1, 3 / 8 + kappa M * p.2)

noncomputable def unplace (s : Recorder.Control M) (p : ℝ × ℝ) : ℝ × ℝ :=
  ((p.1 - origin s) / kappa M, (p.2 - 3 / 8) / kappa M)

@[simp] theorem unplace_place (s : Recorder.Control M) (p : ℝ × ℝ) :
    unplace s (place s p) = p := by
  apply Prod.ext <;> dsimp [unplace, place] <;> field_simp [(kappa_pos M).ne'] <;> ring

@[simp] theorem place_unplace (s : Recorder.Control M) (p : ℝ × ℝ) :
    place s (unplace s p) = p := by
  apply Prod.ext <;> dsimp [unplace, place] <;> field_simp [(kappa_pos M).ne'] <;> ring

noncomputable def physicalBox (s : Recorder.Control M) (P : Rectangle) : Rectangle :=
  ⟨place s P.lower, place s P.upper⟩

 
theorem physicalBox_carrier (s : Recorder.Control M) (P : Rectangle) :
    (physicalBox s P).carrier = place s '' P.carrier := by
  ext q
  constructor
  · intro hq
    refine ⟨unplace s q, ?_, place_unplace s q⟩
    change (P.lower.1 ≤ (q.1 - origin s) / kappa M ∧
      (q.1 - origin s) / kappa M ≤ P.upper.1) ∧
      (P.lower.2 ≤ (q.2 - 3 / 8) / kappa M ∧
      (q.2 - 3 / 8) / kappa M ≤ P.upper.2)
    change (origin s + kappa M * P.lower.1 ≤ q.1 ∧
      q.1 ≤ origin s + kappa M * P.upper.1) ∧
      (3 / 8 + kappa M * P.lower.2 ≤ q.2 ∧
      q.2 ≤ 3 / 8 + kappa M * P.upper.2) at hq
    simp only [le_div_iff₀ (kappa_pos M), div_le_iff₀ (kappa_pos M)]
    constructor <;> constructor <;> nlinarith [hq.1.1, hq.1.2, hq.2.1, hq.2.2]
  · rintro ⟨p, hp, rfl⟩
    change (origin s + kappa M * P.lower.1 ≤ origin s + kappa M * p.1 ∧
      origin s + kappa M * p.1 ≤ origin s + kappa M * P.upper.1) ∧
      (3 / 8 + kappa M * P.lower.2 ≤ 3 / 8 + kappa M * p.2 ∧
      3 / 8 + kappa M * p.2 ≤ 3 / 8 + kappa M * P.upper.2)
    have h₁ := mul_le_mul_of_nonneg_left hp.1.1 (kappa_pos M).le
    have h₂ := mul_le_mul_of_nonneg_left hp.1.2 (kappa_pos M).le
    have h₃ := mul_le_mul_of_nonneg_left hp.2.1 (kappa_pos M).le
    have h₄ := mul_le_mul_of_nonneg_left hp.2.2 (kappa_pos M).le
    constructor <;> constructor <;> linarith

theorem physical_gap_same (s : Recorder.Control M) {P Q : Rectangle} {δ : ℝ}
    (h : P.SeparatedBy δ Q) :
    (physicalBox s P).SeparatedBy (kappa M * δ) (physicalBox s Q) := by
  rcases h with (h | h) | (h | h)
  all_goals have hm := mul_le_mul_of_nonneg_left h (kappa_pos M).le
  · exact .inl (.inl (by dsimp [physicalBox, place]; nlinarith))
  · exact .inl (.inr (by dsimp [physicalBox, place]; nlinarith))
  · exact .inr (.inl (by dsimp [physicalBox, place]; nlinarith))
  · exact .inr (.inr (by dsimp [physicalBox, place]; nlinarith))

theorem physical_gap_different {s t : Recorder.Control M} {P Q : Rectangle}
    (hs : s ≠ t) (hP : P.InUnit) (hQ : Q.InUnit) :
    (physicalBox s P).SeparatedBy (kappa M) (physicalBox t Q) := by
  have hk := kappa_pos M
  have hpU := mul_le_mul_of_nonneg_left hP.2.2.1 hk.le
  have hpL := mul_nonneg hk.le hP.1
  have hqU := mul_le_mul_of_nonneg_left hQ.2.2.1 hk.le
  have hqL := mul_nonneg hk.le hQ.1
  rcases state_gap hs with hst | hst
  · exact .inl (.inl (by dsimp [physicalBox, place]; nlinarith))
  · exact .inl (.inr (by dsimp [physicalBox, place]; nlinarith))
end Bridge
end Solenoidal

end OAI