import OAI.Computability.Superstring.GroupSupply

namespace OAI

namespace Superstring.BitCode
variable {α : Type} [Inhabited α] [DecidableEq α]
def lexLT (lt : α × α → Bool) (v w : List α) : Bool :=
  (equal v (w.take v.length) && less v.length w.length) ||
    (List.range (min v.length w.length)).any (fun i =>
      equal (v.take i) (w.take i) && lt (v[i]?.getD default,w[i]?.getD default))

omit [Inhabited α] [DecidableEq α] in
theorem take_eq_iff {v w : List α} {i : ℕ} (hv : i ≤ v.length) (hw : i ≤ w.length) :
    v.take i = w.take i ↔ ∀ j, (hj : j < i) → v[j]'(by omega) = w[j]'(by omega) := by
  constructor
  · intro he j hj
    have hh := congrArg (fun u => u[j]?) he
    simpa only [List.getElem?_take,ite_eq_left hj,List.getElem?_eq_getElem (by omega : j<v.length),
      List.getElem?_eq_getElem (by omega : j<w.length),Option.some.injEq] using hh
  · intro he
    apply List.ext_getElem
    · simp [List.length_take, Nat.min_eq_left hv,Nat.min_eq_left hw]
    · intro j hj hj'
      have hji : j < i := lt_of_lt_of_le hj (List.length_take_le _ _)
      simp only [List.getElem_take,he j hji]

theorem lexLT_eq [LinearOrder α] (lt : α × α → Bool)
    (hlt : ∀ x, lt x = decide (x.1<x.2)) (v w : List α) :
    lexLT lt v w = true ↔ v<w := by
  rw [List.lt_iff_exists]
  simp only [lexLT,Bool.or_eq_true,Bool.and_eq_true,equal,less,decide_eq_true_eq,
    List.any_eq_true,List.mem_range]
  apply or_congr Iff.rfl
  constructor
  · rintro ⟨i,hi,he,hlt'⟩
    have hv : i<v.length := lt_of_lt_of_le hi (Nat.min_le_left ..)
    have hw : i<w.length := lt_of_lt_of_le hi (Nat.min_le_right ..)
    refine ⟨i,hv,hw,(take_eq_iff hv.le hw.le).mp he,?_⟩
    simpa only [hlt,List.getElem?_eq_getElem hv,List.getElem?_eq_getElem hw,
      Option.getD_some,decide_eq_true_eq] using hlt'
  · rintro ⟨i,hv,hw,he,hl⟩
    refine ⟨i,lt_min hv hw,(take_eq_iff hv.le hw.le).mpr he,?_⟩
    simpa only [hlt,List.getElem?_eq_getElem hv,List.getElem?_eq_getElem hw,
      Option.getD_some,decide_eq_true_eq] using hl

variable [Coded α]
@[fun_prop] theorem poly_lexLT {lt : α × α → Bool} (hlt : Poly lt) :
    Poly (fun q : List α × List α => lexLT lt q.1 q.2) := by
  unfold lexLT
  apply Poly.or.comp (f := fun q : List α × List α =>
    (equal q.1 (q.2.take q.1.length) && less q.1.length q.2.length,
    (List.range (min q.1.length q.2.length)).any (fun i =>
      equal (q.1.take i) (q.2.take i) && lt (q.1[i]?.getD default,q.2[i]?.getD default))))
  apply Poly.pair (by fun_prop)
  apply Poly.anyFn (p := fun q : (List α × List α) × ℕ =>
    equal (q.1.1.take q.2) (q.1.2.take q.2) && lt (q.1.1[q.2]?.getD default,q.1.2[q.2]?.getD default))
  · apply Poly.and.comp (f := fun q : (List α × List α) × ℕ =>
      (equal (q.1.1.take q.2) (q.1.2.take q.2),lt (q.1.1[q.2]?.getD default,q.1.2[q.2]?.getD default)))
    apply Poly.pair (by fun_prop)
    apply hlt.comp
    exact ((Poly.getD default).comp (f := fun q : (List α × List α) × ℕ => (q.1.1,q.2)) (by fun_prop)).pair
      ((Poly.getD default).comp (f := fun q : (List α × List α) × ℕ => (q.1.2,q.2)) (by fun_prop))
  · fun_prop

@[fun_prop] theorem Poly.ltBool : Poly (fun q : Bool × Bool => decide (q.1 < q.2)) := by
  have h : Poly (fun q : Bool × Bool => !q.1 && q.2) := by fun_prop
  convert h using 1
  funext q
  rcases q with ⟨a,b⟩
  cases a <;> cases b <;> rfl

@[fun_prop] theorem Poly.ltList [LinearOrder α] (h : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : List α × List α => decide (q.1<q.2)) := by
  convert poly_lexLT h using 1
  funext q
  apply Bool.eq_iff_iff.mpr
  simpa only [decide_eq_true_eq] using (lexLT_eq _ (fun _ => rfl) q.1 q.2).symm

@[fun_prop] theorem Poly.leList [LinearOrder α] (h : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : List α × List α => decide (q.1≤q.2)) := by
  have H := Poly.not.comp ((Poly.ltList h).comp (Poly.snd.pair Poly.fst))
  convert H using 1
  funext q
  simp only [Function.comp_apply,← decide_not,not_lt]
end Superstring.BitCode


namespace Superstring.RotationCode
open BitCode Hierarchical
variable {α : Type} [Inhabited α] [LinearOrder α]

omit [Inhabited α] [LinearOrder α] in
theorem forward_mod {A : ℤ → α} {p : ℕ} (per : Function.Periodic A (p:ℤ)) (t : ℤ) (n : ℕ) :
    forward A t (n % p) = forward A t n := by
  have hh := periodic_emod (fun x => A (t+x)) (p:ℤ)
    (by intro x; simpa only [← add_assoc] using per (t+x)) (n:ℤ)
  simpa only [forward, Pi.toLex_apply, Int.natCast_emod] using hh

omit [Inhabited α] in
theorem window_lt_iff {A : ℤ → α} {p : ℕ} (hp : 0 < p)
    (per : Function.Periodic A (p:ℤ)) (a b : ℤ) :
    textWord A a (a+p) < textWord A b (b+p) ↔ forward A a < forward A b := by
  have hlen (t : ℤ) : (textWord A t (t+p)).length = p := by simp [length_textWord]
  rw [List.lt_iff_exists]
  constructor
  · rintro (⟨_,hh⟩|⟨i,hi,hj,he,hl⟩)
    · simp only [hlen,lt_self_iff_false] at hh
    · refine ⟨i,?_,?_⟩
      · intro j hj
        have hh := he j hj
        simpa only [textWord,List.getElem_ofFn,forward,Pi.toLex_apply] using hh
      · simpa only [textWord,List.getElem_ofFn,forward,Pi.toLex_apply] using hl
  · rintro ⟨i,he,hl⟩
    have hi : i < p := by
      by_contra hn
      have hm : i%p < i := lt_of_lt_of_le (Nat.mod_lt i hp) (by omega)
      have hh := he (i%p) hm
      rw [forward_mod per,forward_mod per] at hh
      exact (ne_of_lt hl) hh
    right
    refine ⟨i,by simpa only [hlen] using hi,by simpa only [hlen] using hi,?_,?_⟩
    · intro j hj
      simpa only [textWord,List.getElem_ofFn,forward,Pi.toLex_apply] using he j hj
    · simpa only [textWord,List.getElem_ofFn,forward,Pi.toLex_apply] using hl

omit [Inhabited α] in
theorem window_le_iff {A : ℤ → α} {p : ℕ} (hp : 0 < p)
    (per : Function.Periodic A (p:ℤ)) (a b : ℤ) :
    textWord A a (a+p) ≤ textWord A b (b+p) ↔ forward A a ≤ forward A b := by
  rw [← not_lt,← not_lt,window_lt_iff hp per]
  rfl

def phase (U : List α) : ℕ :=
  ThreadArray.first U.length (fun i => (List.range U.length).all (fun j =>
    decide (PeriodWord.window U j ((j:ℤ)+U.length) ≤ PeriodWord.window U i ((i:ℤ)+U.length))))

theorem phase_spec (U : List α) (hp : 0 < U.length) :
    phase U < U.length ∧ ∀ x, forward (PeriodWord.text U) x ≤ forward (PeriodWord.text U) (phase U) := by
  obtain ⟨t,ht0,htp,ht⟩ := exists_greatest_rotation (PeriodWord.text U) U.length hp (PeriodWord.periodic U)
  have hpref (x y : ℤ) : PeriodWord.window U x (x+U.length) ≤ PeriodWord.window U y (y+U.length) ↔
      forward (PeriodWord.text U) x ≤ forward (PeriodWord.text U) y := by
    simp only [PeriodWord.window_eq,window_le_iff hp (PeriodWord.periodic U)]
  have hex : ∃ i < U.length, (List.range U.length).all (fun j =>
      decide (PeriodWord.window U j ((j:ℤ)+U.length) ≤ PeriodWord.window U i ((i:ℤ)+U.length))) = true := by
    refine ⟨t.toNat,by omega,List.all_eq_true.mpr (fun j _ => ?_)⟩
    apply decide_eq_true
    apply (hpref _ _).mpr
    simpa only [Int.toNat_of_nonneg ht0] using ht j
  have hs := ThreadArray.first_spec hex
  refine ⟨hs.1,?_⟩
  intro x
  let r := (x % (U.length:ℤ)).toNat
  have hrlt : r < U.length := by
    have := Int.emod_nonneg x (show (U.length:ℤ) ≠ 0 by omega)
    have := Int.emod_lt_of_pos x (show (0:ℤ) < U.length by omega)
    dsimp only [r]; omega
  have hle := List.all_eq_true.mp hs.2.1 r (List.mem_range.mpr hrlt)
  have hh := (hpref _ _).mp (of_decide_eq_true hle)
  have he : forward (PeriodWord.text U) x = forward (PeriodWord.text U) r := by
    apply congrArg toLex
    funext n
    have hr : (r:ℤ) = x % (U.length:ℤ) := by
      exact Int.toNat_of_nonneg (Int.emod_nonneg _ (by omega))
    have hdiv := Int.emod_add_ediv_mul x (U.length:ℤ)
    have hh := (PeriodWord.periodic U).sub_int_mul_eq (x := x+n) (x/U.length)
    simp only [Int.cast_id] at hh
    have hx : x+n-(x/(U.length:ℤ))*U.length = (r:ℤ)+n := by omega
    rw [hx] at hh
    exact hh.symm
  rw [he]
  exact hh

variable [Coded α]
@[fun_prop] theorem poly_phase (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (phase (α := α)) := by
  have hle := BitCode.Poly.leList hlt
  unfold phase ThreadArray.first
  apply (BitCode.Poly.headD 0).comp
  apply BitCode.Poly.filterFn
    (p := fun t : List α × ℕ => (List.range t.1.length).all (fun j =>
      decide (PeriodWord.window t.1 j ((j:ℤ)+t.1.length) ≤ PeriodWord.window t.1 t.2 ((t.2:ℤ)+t.1.length))))
  · apply BitCode.Poly.allFn
      (p := fun t : (List α × ℕ) × ℕ =>
        decide (PeriodWord.window t.1.1 t.2 ((t.2:ℤ)+t.1.1.length) ≤
          PeriodWord.window t.1.1 t.1.2 ((t.1.2:ℤ)+t.1.1.length)))
    · exact hle.comp (f := fun t : (List α × ℕ) × ℕ =>
        (PeriodWord.window t.1.1 t.2 ((t.2:ℤ)+t.1.1.length),
          PeriodWord.window t.1.1 t.1.2 ((t.1.2:ℤ)+t.1.1.length))) (by fun_prop)
    · fun_prop
  · fun_prop
end Superstring.RotationCode


namespace Superstring.RotationCode
open BitCode Hierarchical
variable {α : Type} [LinearOrder α]
theorem maximal_unique {A : ℤ → α} {p : ℕ} (h : Primitive A p)
    {a b : ℤ} (ha : 0 ≤ a) (hap : a < p) (hb : 0 ≤ b) (hbp : b < p)
    (hA : ∀ x, forward A x ≤ forward A a) (hB : ∀ x, forward A x ≤ forward A b) : a = b := by
  have he : forward A a = forward A b := le_antisymm (hB a) (hA b)
  have he' : (fun x => A (x+a)) = (fun x => A (x+b)) := by
    apply periodic_eq_of_forward_eq _ _ p p h.positive h.positive
      (fun x => by simpa only [add_right_comm] using h.periodic (x+a))
      (fun x => by simpa only [add_right_comm] using h.periodic (x+b)) 0
    simpa only [forward_shift,zero_add] using he
  exact h.alignment_unique ha hap hb hbp (congrFun he')

variable [Inhabited α]
theorem phase_eq_distinguished {G : Type} {V : Set (List α)}
    (C : LayerCollection V G) (g : G) (hprim : Primitive (C.text g) (C.period g))
    (U : List α) (hlen : U.length = C.period g) (ht : PeriodWord.text U = C.text g) :
    (phase U : ℤ) = C.distinguished g := by
  obtain ⟨hp,hm⟩ := phase_spec U (by rw [hlen]; exact C.positive g)
  have hs := (exists_greatest_rotation (C.text g) (C.period g) (C.positive g) (C.periodic g)).choose_spec
  apply maximal_unique hprim (by omega) (by omega) hs.1 hs.2.1
  · simpa only [ht] using hm
  · exact C.distinguished_max g
end Superstring.RotationCode

end OAI