import OAI.Computability.StarHeight.ClockResidues

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uC uC2 uC3 uT uC4 uAlphabet uAlphabet2 uAlphabet3
universe uAlphabet4

namespace PeriodicClock

open RobustClock
open scoped BigOperators

lemma prime_mesh {C : Type uC} [Fintype C] (B : ℕ) {ε : ℝ} (hε : 0 < ε) :
    ∃ n : C → ℕ, Function.Injective n ∧
      (∀ c, Nat.Prime (n c) ∧ B < n c ∧ 1 / (2 * (n c : ℝ)) < ε) := by
  obtain ⟨L, hL⟩ := exists_nat_gt (1 / ε)
  obtain ⟨n, hn, hprime⟩ := large_primes (C := C) (max B L)
  refine ⟨n, hn, fun c => ⟨(hprime c).1,
    lt_of_le_of_lt (le_max_left _ _) (hprime c).2, ?_⟩⟩
  have hl : (1 / ε : ℝ) < n c := hL.trans (by
    exact_mod_cast lt_of_le_of_lt (le_max_right _ _) (hprime c).2)
  have hnpos : (0 : ℝ) < n c := by exact_mod_cast (hprime c).1.pos
  apply (div_lt_iff₀ (by positivity : (0 : ℝ) < 2 * n c)).mpr
  have hh := (div_lt_iff₀ hε).mp hl
  nlinarith

lemma prime_pairwise {C : Type uC2} (n : C → ℕ) (hinj : Function.Injective n)
    (hn : ∀ c, Nat.Prime (n c)) : Pairwise (Function.onFun Nat.Coprime n) := by
  intro i j hij
  apply (hn i).coprime_iff_not_dvd.mpr
  intro hd
  have he : n i = n j := ((hn j).eq_one_or_self_of_dvd (n i) hd).resolve_left (hn i).ne_one
  exact hij (hinj he)

lemma small_coprime {p B : ℕ} (hp : Nat.Prime p) (hB : 0 < B) (hBp : B < p) :
    Nat.Coprime B p := by
  apply Nat.Coprime.symm
  apply hp.coprime_iff_not_dvd.mpr
  intro hd
  exact (not_le_of_gt hBp) (Nat.le_of_dvd hB hd)

lemma unbounded_residue {C : Type uC3} [Fintype C] (n : C → ℕ)
    (hn : ∀ c, 0 < n c) (hp : Pairwise (Function.onFun Nat.Coprime n))
    {B : ℕ} (hB : 0 < B) (hBc : ∀ c, Nat.Coprime B (n c))
    {ε : ℝ} (hε : 0 < ε) (hmesh : ∀ c, 1 / (2 * (n c : ℝ)) < ε)
    (r : ℤ) (v : C → RobustClock.Circle) (L : ℤ) :
    ∃ z : ℤ, L < z ∧ z % B = r % B ∧
      dist (speedMap (fun c => 1 / (n c : ℝ)) z) v < ε := by
  classical
  let φ := speedMap (fun c => 1 / (n c : ℝ))
  let R := ∏ c, n c
  have hR : (0 : ℤ) < R := by exact_mod_cast Finset.prod_pos (fun c _ => hn c)
  have hpR : φ (R : ℤ) = 0 := by
    simpa only [φ, Nat.cast_one] using period n (fun _ => 1) hn
  obtain ⟨a, _, ha⟩ := net n hn hp B hBc hε hmesh (v - φ r)
  let b : ℤ := r + (a : ℤ) * B
  have hb : dist (φ b) v < ε := by
    dsimp [b]
    rw [map_add]
    have hh : v = φ r + (v - φ r) := by abel
    conv_lhs => rw [hh]
    rw [dist_add_left]
    exact ha
  let q : ℤ := |L| + |b| + 1
  let z := b + (q * B) * R
  have hq : 0 < q := by dsimp [q]; positivity
  have hBR : (1 : ℤ) ≤ (B : ℤ) * R := by
    have hB' : (0 : ℤ) < B := by exact_mod_cast hB
    have hh := mul_pos hB' hR
    omega
  have hzl : L < z := by
    have hh := mul_le_mul_of_nonneg_left hBR hq.le
    dsimp [z, q] at *
    have hL := le_abs_self L
    have hbb := neg_abs_le b
    nlinarith
  have hzm : z % B = r % B := by
    dsimp [z, b]
    rw [mul_right_comm q (B : ℤ) (R : ℤ), Int.add_mul_emod_self_right,
      Int.add_mul_emod_self_right]
  refine ⟨z, hzl, hzm, ?_⟩
  have hφz : φ z = φ b := by
    dsimp [z]
    have hmul := map_zsmul φ (q * B) (R : ℤ)
    simp only [zsmul_eq_mul, Int.cast_id] at hmul
    rw [map_add, hmul, hpR, smul_zero, add_zero]
  change dist (φ z) v < ε
  rwa [hφz]

end PeriodicClock

namespace ScheduleClock

open RobustClock PeriodicClock
open scoped BigOperators

theorem exists_stencil_clock {T : Type uT} {C : Type uC4} [Fintype T] [Fintype C]
    (N : ℕ) (S : Specification T (Fin N) C) (B : ℕ) (hB : 0 < B)
    (r : Fin N → ℤ) (lower : (Fin N → ℤ) → ℕ → ℕ) :
    ∃ (R : ℕ) (p : Fin N → ℤ) (n a : C → ℕ),
      0 < R ∧
      (∀ i, p i % B = r i % B ∧ (2 * (B * R) + 2 : ℤ) < p i) ∧
      (∀ i j, i < j → 2 * p i + (2 * (B * R) + 2 : ℤ) < p j) ∧
      Function.Injective n ∧
      (∀ c, Nat.Prime (n c) ∧ lower p (B * R) < n c ∧ 1 ≤ a c ∧ a c < n c) ∧
      (∀ i, dist (speedMap (fun c => (a c : ℝ) / n c) (p i)) (S.v i) < S.η) ∧
      (∀ v : C → RobustClock.Circle, ∃ j : ℕ, j < R ∧
        dist (speedMap (fun c => (a c : ℝ) / n c) (j * B)) v < S.ρ) := by
  classical
  let ε := min (S.ρ / 3) (S.η / 3)
  have hε : 0 < ε := lt_min (div_pos S.radius_pos (by norm_num))
    (div_pos S.tolerance_pos (by norm_num))
  obtain ⟨n₀, hn₀inj, hn₀⟩ := prime_mesh (C := C) B hε
  have hprim c := (hn₀ c).1
  have hn₀pos c := (hprim c).pos
  have hpair := prime_pairwise n₀ hn₀inj hprim
  have hcop c := small_coprime (hprim c) hB (hn₀ c).2.1
  let R := ∏ c, n₀ c
  have hR : 0 < R := Finset.prod_pos (fun c _ => hn₀pos c)
  obtain ⟨p, hp, hspread⟩ := SpacedStencil.exists_points N (2 * (B * R : ℕ) + 2)
    (fun i z => z % B = r i % B ∧
      dist (speedMap (fun c => 1 / (n₀ c : ℝ)) z) (S.v i) < ε)
    (fun i L => unbounded_residue n₀ hn₀pos hpair hB hcop hε
      (fun c => (hn₀ c).2.2) (r i) (S.v i) L)
  let F : Finset ℤ := Finset.univ.image p ∪ (Finset.range R).image (fun j => (j * B : ℕ))
  have hs c : 0 < (1 / (n₀ c : ℝ)) ∧ 1 / (n₀ c : ℝ) < 1 := by
    have hh : (1 : ℝ) < n₀ c := by exact_mod_cast (hprim c).one_lt
    exact ⟨by positivity, (div_lt_one (by positivity)).mpr hh⟩
  obtain ⟨n, a, hn, hna, hclose⟩ := approximate_finite (fun c => 1 / (n₀ c : ℝ)) hs
    (lower p (B * R)) F hε
  refine ⟨R, p, n, a, hR, fun i => ⟨(hp i).1.1, (hp i).2⟩, hspread,
    hn, hna, ?_, ?_⟩
  · intro i
    have hc := hclose (p i) (Finset.mem_union_left _ (Finset.mem_image.mpr
      ⟨i, Finset.mem_univ i, rfl⟩))
    have ht := (dist_triangle _ _ _).trans_lt (add_lt_add hc (hp i).1.2)
    have he : ε ≤ S.η / 3 := min_le_right _ _
    exact ht.trans (by linarith [S.tolerance_pos])
  · intro v
    obtain ⟨j, hj, hjv⟩ := net n₀ hn₀pos hpair B hcop hε (fun c => (hn₀ c).2.2) v
    have hc := hclose ((j * B : ℕ) : ℤ) (Finset.mem_union_right _ (Finset.mem_image.mpr
      ⟨j, Finset.mem_range.mpr hj, rfl⟩))
    refine ⟨j, hj, ?_⟩
    have ht := (dist_triangle _ _ _).trans_lt (add_lt_add hc hjv)
    have he : ε ≤ S.ρ / 3 := min_le_left _ _
    exact ht.trans (by linarith [S.radius_pos])

end ScheduleClock

namespace EpisodeEnd

open LocalMarkers

variable {Alphabet : Type uAlphabet}

def FirstMismatch (w v : ℤ → Alphabet) (z : ℤ) (K : ℕ) (q : ℤ) : Prop :=
  z + K ≤ q ∧ w q ≠ v q ∧ AgreesOn w v z q

lemma firstMismatch_unique {w v : ℤ → Alphabet} {z z' q q' : ℤ} {K : ℕ}
    (h : FirstMismatch w v z K q) (h' : FirstMismatch w v z' K q')
    (hover : |z - z'| < K) : q = q' := by
  have hq := h.1
  have hq' := h'.1
  have hz : z ≤ q' := by
    have hh := (abs_lt.mp hover).2
    omega
  have hz' : z' ≤ q := by
    have hh := (abs_lt.mp hover).1
    omega
  rcases lt_trichotomy q q' with hq | hq | hq
  · exact False.elim (h.2.1 (h'.2.2 q hz' hq))
  · exact hq
  · exact False.elim (h'.2.1 (h.2.2 q' hz hq))

lemma shortCont_congr {d K : ℕ} {w w' v : ℤ → Alphabet} {z : ℤ}
    (he : AgreesOn w w' z (z + K)) :
    ShortContinuation d K w z v ↔ ShortContinuation d K w' z v := by
  constructor <;> intro h
  · refine ⟨h.1, fun x hx hx' => ?_⟩
    exact (he x hx hx').symm.trans (h.2 x hx hx')
  · refine ⟨h.1, fun x hx hx' => ?_⟩
    exact (he x hx hx').trans (h.2 x hx hx')

def EndAt (d K : ℕ) (tail : ℤ) (w : ℤ → Alphabet) (z : ℤ)
    (η : Option ℤ) (b : ℤ) : Prop :=
  match η with
  | some q => b = q + tail
  | none => ∃ v, ShortContinuation d K w z v ∧ FirstMismatch w v z K (b - tail)

def clockAnchor (ζ : Option ℤ) (b tail : ℤ) : ℤ := ζ.getD (b - tail)

lemma EndAt.unique {d K : ℕ} {tail z b b' : ℤ} {w : ℤ → Alphabet} {η : Option ℤ}
    (hK : (d : ℤ) ^ 2 ≤ K) (hKpos : 0 < K)
    (h : EndAt d K tail w z η b) (h' : EndAt d K tail w z η b') : b = b' := by
  cases η with
  | some q => exact h.trans h'.symm
  | none =>
    obtain ⟨v, hv, hm⟩ := h
    obtain ⟨v', hv', hm'⟩ := h'
    have he := short_continuations_equal hv hv' (by simpa using hK)
    subst v'
    have hh := firstMismatch_unique hm hm' (by simpa using hKpos)
    omega

lemma shared_end {d K : ℕ} {tail s z z' b b' : ℤ}
    {w w' : ℤ → Alphabet} {η : Option ℤ}
    (htail : 0 < tail) (hover : (d : ℤ) ^ 2 ≤ (K : ℤ) - |z - z'|)
    (hover' : |z - z'| < K)
    (hseed : s ≤ z ∧ z + K ≤ min b b' ∧ s ≤ z' ∧ z' + K ≤ min b b')
    (he : AgreesOn w w' s (min b b'))
    (h : EndAt d K tail w z η b) (h' : EndAt d K tail w' z' η b') :
    b = b' := by
  cases η with
  | some q => exact h.trans h'.symm
  | none =>
    obtain ⟨v, hv, hm⟩ := h
    obtain ⟨v', hv', hm'⟩ := h'
    have hseed' : AgreesOn w w' z' (z' + K) := by
      intro x hx hx'
      exact he x (hseed.2.2.1.trans hx) (lt_of_lt_of_le hx' hseed.2.2.2)
    have hvw : ShortContinuation d K w z' v' := (shortCont_congr hseed').mpr hv'
    have hvv := short_continuations_equal hv hvw hover
    subst v'
    have hmlo := hm.1
    have hmlo' := hm'.1
    have hz : z ≤ b' - tail := by
      have hh := (abs_lt.mp hover').2
      omega
    have hz' : z' ≤ b - tail := by
      have hh := (abs_lt.mp hover').1
      omega
    rcases lt_trichotomy b b' with hb | hb | hb
    · have hq : b - tail < b' - tail := by omega
      have hqbounds : s ≤ b - tail ∧ b - tail < min b b' := by omega
      have hletter := he (b - tail) hqbounds.1 hqbounds.2
      exact False.elim (hm.2.1 (hletter.trans (hm'.2.2 _ hz' hq)))
    · exact hb
    · have hq : b' - tail < b - tail := by omega
      have hqbounds : s ≤ b' - tail ∧ b' - tail < min b b' := by omega
      have hletter := he (b' - tail) hqbounds.1 hqbounds.2
      exact False.elim (hm'.2.1 (hletter.symm.trans (hm.2.2 _ hz hq)))

lemma transfer_end {d K : ℕ} {tail z z' b : ℤ} {w : ℤ → Alphabet} {η : Option ℤ}
    (hover : (d : ℤ) ^ 2 ≤ (K : ℤ) - |z - z'|)
    (hover' : |z - z'| < K)
    (hseed : η = none → ∃ v', ShortContinuation d K w z' v')
    (h : EndAt d K tail w z η b) : EndAt d K tail w z' η b := by
  cases η with
  | some q => exact h
  | none =>
    obtain ⟨v, hv, hm⟩ := h
    obtain ⟨v', hv'⟩ := hseed rfl
    have he := short_continuations_equal hv hv' hover
    subst v'
    refine ⟨v, hv', ?_⟩
    have hmlo := hm.1
    have hz' : z' ≤ b - tail := by
      have hh := (abs_lt.mp hover').1
      omega
    have hq : z' + K ≤ b - tail := by
      by_contra hn
      exact hm.2.1 (hv'.2 _ hz' (by omega))
    refine ⟨hq, hm.2.1, fun x hx hx' => ?_⟩
    by_cases hxz : z ≤ x
    · exact hm.2.2 x hxz hx'
    · apply hv'.2 x hx
      have hh := (abs_lt.mp hover').2
      omega

end EpisodeEnd

namespace LocalMarkers

variable (Alphabet : Type uAlphabet2) (d K : ℕ)

structure Rule where
  r : ℤ
  radius_ge : (K : ℤ) ≤ r
  markers : (ℤ → Alphabet) → Set ℤ
  separated : ∀ w x, x ∈ markers w → ∀ y, y ∈ markers w → x ≠ y →
    (d : ℤ) ≤ |x - y|
  locality : ∀ w w' x, AgreesOn w w' (x - r) (x + r) →
    (x ∈ markers w ↔ x ∈ markers w')
  translate : ∀ w a x, x ∈ markers (fun i => w (i + a)) ↔ x + a ∈ markers w
  periodic : ∀ w z, (∀ x : ℤ, z - d ≤ x → x ≤ z + d → x ∉ markers w) →
    ∃ a : ℕ, 0 < a ∧ a < d ∧ Period (fun i : Fin K => w (z + i.val)) a

lemma nonempty_rule [Fintype Alphabet] (hd : 2 ≤ d) (hK : 3 * d ^ 2 < K) :
    Nonempty (Rule Alphabet d K) := by
  obtain ⟨r, hr, m, hsep, hloc, htrans, hper⟩ := exists_markers (Alphabet := Alphabet) hd hK
  exact ⟨⟨r, hr, m, hsep, hloc, htrans, hper⟩⟩

end LocalMarkers

namespace EndSearch

open LocalMarkers

lemma search_congr {S S' : Set ℤ} {B D a z : ℤ}
    (he : ∀ m, z - (a + (B - 1) * D) ≤ m → m ≤ z + (a + (B - 1) * D) →
      (m ∈ S ↔ m ∈ S')) : search S B D a z = search S' B D a z := by
  have hf : eligibleSet S B D a z = eligibleSet S' B D a z := by
    ext m
    simp only [eligibleSet, Finset.mem_filter, Finset.mem_Icc, Eligible]
    constructor
    · rintro ⟨⟨hl, hr⟩, hm, hw⟩
      exact ⟨⟨hl, hr⟩, (he m hl hr).mp hm, hw⟩
    · rintro ⟨⟨hl, hr⟩, hm, hw⟩
      exact ⟨⟨hl, hr⟩, (he m hl hr).mpr hm, hw⟩
  simp only [search, hf]

lemma search_local {Alphabet : Type uAlphabet3} {d K : ℕ} (R : Rule Alphabet d K)
    (B D a z : ℤ) {w w' : ℤ → Alphabet}
    (he : AgreesOn w w' (z - (a + (B - 1) * D) - R.r)
      (z + (a + (B - 1) * D) + R.r)) :
    search (R.markers w) B D a z = search (R.markers w') B D a z := by
  apply search_congr
  intro m hm hm'
  apply R.locality
  intro x hx hx'
  exact he x (by omega) (by omega)

lemma absent_continuation {Alphabet : Type uAlphabet4} {d K : ℕ} (R : Rule Alphabet d K)
    (hK : d ≤ K) {B D z : ℤ} {w : ℤ → Alphabet} (hB : 0 < B) (hD : 0 ≤ D)
    (hn : search (R.markers w) B D d z = none) :
    ∃ v, ShortContinuation d K w z v := by
  apply short_continuation_exists hK
  apply R.periodic
  intro m hlo hhi hm
  apply (search_none hB hD).mp hn m
  exact ⟨hm, (abs_le.mpr (show -(d : ℤ) ≤ m - z ∧ m - z ≤ d by omega)).trans
    (width_bounds hB hD).1⟩

end EndSearch

end GeneralizedStarHeight

end OAI