import OAI.Computability.WeisfeilerLeman.Circuits

namespace OAI

universe uJ

namespace WLTime

structure OneTape where
  states : ℕ
  symbols : ℕ
  states_ge : 3  ≤  states
  symbols_ge : 3  ≤  symbols
  transition : Fin states → Fin symbols → Fin states × Fin symbols × Move

namespace OneTape
variable (M : OneTape)
open scoped Classical

abbrev Cell := Fin M.symbols × Option (Fin M.states)

def action (q : Fin M.states) (s : Fin M.symbols) : Fin M.states × Fin M.symbols × Move :=
  if q.val=1 ∨ q.val=2 then (q,s,.stay) else M.transition q s

structure Config (J : Type uJ) where
  state : Fin M.states
  head : J
  tape : J → Fin M.symbols

def moveAt {J : Type uJ} (shift : Equiv.Perm J) : Move → J → J
  | .left => shift.symm
  | .stay => id
  | .right => shift

open scoped Classical in
noncomputable def step {J : Type uJ} (shift : Equiv.Perm J) (C : M.Config J) : M.Config J :=
  let a := M.action C.state (C.tape C.head)
  { state := a.1
    head := moveAt shift a.2.2 C.head
    tape := Function.update C.tape C.head a.2.1 }

open scoped Classical in
noncomputable def snapshot {J : Type uJ} (C : M.Config J) (j : J) : M.Cell :=
  (C.tape j,if j=C.head then some C.state else none)

def written (c : M.Cell) : Fin M.symbols := match c.2 with
  | none => c.1
  | some q => (M.action q c.1).2.1

def arrival (d : Move) (c : M.Cell) : Option (Fin M.states) := match c.2 with
  | none => none
  | some q => if (M.action q c.1).2.2=d then some (M.action q c.1).1 else none

def localRule (l c r : M.Cell) : M.Cell :=
  (M.written c,(M.arrival .stay c).or (M.arrival .right l) |>.or (M.arrival .left r))

variable {J : Type uJ}

theorem written_snapshot (C : M.Config J) (j : J) :
    M.written (M.snapshot C j) =
      if j=C.head then (M.action C.state (C.tape C.head)).2.1 else C.tape j := by
  classical
  by_cases hj : j=C.head <;> simp [written,snapshot,hj]

theorem arrival_snapshot (C : M.Config J) (j : J) (d : Move) :
    M.arrival d (M.snapshot C j) =
      if j=C.head ∧ (M.action C.state (C.tape C.head)).2.2=d then
        some (M.action C.state (C.tape C.head)).1 else none := by
  classical
  by_cases hj : j=C.head <;> simp [arrival,snapshot,hj]

theorem moveAt_eq_iff (shift : Equiv.Perm J) (d : Move) (h j : J) :
    j=moveAt shift d h ↔ (j=h ∧ d=.stay) ∨
      (shift.symm j=h ∧ d=.right) ∨ (shift j=h ∧ d=.left) := by
  cases d with
  | left => simp [moveAt,Equiv.eq_symm_apply]
  | stay => simp [moveAt]
  | right => simp [moveAt,Equiv.symm_apply_eq]

theorem snapshot_step (shift : Equiv.Perm J) (C : M.Config J) (j : J) :
    M.snapshot (M.step shift C) j =
      M.localRule (M.snapshot C (shift.symm j)) (M.snapshot C j) (M.snapshot C (shift j)) := by
  classical
  apply Prod.ext
  · change (Function.update C.tape C.head (M.action C.state (C.tape C.head)).2.1) j =
      M.written (M.snapshot C j)
    rw [M.written_snapshot]
    exact Function.update_apply _ _ _ _
  · change (if j=moveAt shift (M.action C.state (C.tape C.head)).2.2 C.head then
        some (M.action C.state (C.tape C.head)).1 else none) =
      ((M.arrival .stay (M.snapshot C j)).or (M.arrival .right (M.snapshot C (shift.symm j)))).or
        (M.arrival .left (M.snapshot C (shift j)))
    simp only [M.arrival_snapshot,moveAt_eq_iff]
    by_cases h0 : j=C.head ∧ (M.action C.state (C.tape C.head)).2.2=.stay <;>
      by_cases h1 : shift.symm j=C.head ∧ (M.action C.state (C.tape C.head)).2.2=.right <;>
      by_cases h2 : shift j=C.head ∧ (M.action C.state (C.tape C.head)).2.2=.left <;>
      simp [h0,h1,h2]

noncomputable def run {J : Type uJ} (shift : Equiv.Perm J) (C : M.Config J) (t : ℕ) : M.Config J :=
  (M.step shift)^[t] C

theorem run_snapshot (shift : Equiv.Perm J) (C : M.Config J) (t : ℕ) :
    M.snapshot (M.run shift C t) =
      CircuitEncoding.Tableau.run M.localRule shift (M.snapshot C) t := by
  induction t with
  | zero => rfl
  | succ t ih =>
    funext j
    rw [CircuitEncoding.Tableau.run_succ]
    change M.snapshot ((M.step shift)^[t+1] C) j = _
    rw [Function.iterate_succ_apply']
    change M.snapshot (M.step shift (M.run shift C t)) j = _
    rw [M.snapshot_step,ih]

def toTM : TM where
  tapes := 1
  states := M.states
  symbols := M.symbols
  tapes_pos := by decide
  states_ge := M.states_ge
  symbols_ge := M.symbols_ge
  transition q a := let b := M.transition q (a 0)
    (b.1,fun _ => b.2.1,fun _ => b.2.2)

def embed (C : M.Config ℤ) : M.toTM.Config where
  state := C.state
  head := fun _ => C.head
  tape := fun _ => C.tape

def lineShift : Equiv.Perm ℤ := Equiv.addRight 1

theorem moveAt_line (d : Move) (h : ℤ) : moveAt lineShift d h = h+d.displacement := by
  cases d <;> simp [moveAt,lineShift,Move.displacement ]

theorem embed_step (C : M.Config ℤ) : M.embed (M.step lineShift C) = M.toTM.step (M.embed C) := by
  classical
  by_cases hh : C.state.val=1 ∨ C.state.val=2
  · have hc : M.step lineShift C=C := by
      cases C
      simp_all [step,action,moveAt,Function.update_eq_self]
    rw [hc]
    simp [TM.step,TM.halted,embed,hh]
  · simp only [TM.step,TM.halted,embed,hh,ite_false]
    simp only [step,action,hh,ite_false,toTM,moveAt_line]
    congr
    funext a z
    simp only [Function.update_apply]
    split <;> rename_i hz <;> simp only [hz,ite_true,ite_false]

def initial (w : List Bool) : M.Config ℤ where
  state := ⟨0,by have := M.states_ge; omega⟩
  head := 0
  tape z := if 0 ≤ z ∧ z.toNat< w.length then
    M.toTM.symbol (w.getD z.toNat false) else ⟨0,by have := M.symbols_ge; omega⟩

@[simp] theorem embed_initial (w : List Bool) : M.embed (M.initial w)=M.toTM.initial w := by
  unfold embed initial TM.initial
  congr 1
  funext a z
  have ha : a.val=0 := Fin.eq_zero a ▸ rfl
  simp only [ha,true_and]
  split <;> rename_i hz <;> simp [hz] <;> rfl

theorem embed_run (w : List Bool) (t : ℕ) :
    M.embed (M.run lineShift (M.initial w) t)=M.toTM.run w t := by
  induction t with
  | zero => exact M.embed_initial w
  | succ t ih =>
    change M.embed ((M.step lineShift)^[t+1] (M.initial w)) = M.toTM.step^[t+1] (M.toTM.initial w)
    rw [Function.iterate_succ_apply',Function.iterate_succ_apply']
    rw [M.embed_step]
    exact congrArg M.toTM.step ih

theorem step_halted {J : Type uJ} (shift : Equiv.Perm J) (C : M.Config J)
    (hh : C.state.val=1 ∨ C.state.val=2) : M.step shift C=C := by
  cases C
  simp_all [step,action,moveAt,Function.update_eq_self]

theorem run_halted {J : Type uJ} (shift : Equiv.Perm J) (C : M.Config J)
    (hh : C.state.val=1 ∨ C.state.val=2) (t : ℕ) : M.run shift C t=C := by
  unfold run
  exact Function.iterate_fixed (M.step_halted shift C hh) t

theorem line_head_step (C : M.Config ℤ) :
    C.head-1  ≤  (M.step lineShift C).head ∧ (M.step lineShift C).head  ≤  C.head+1 := by
  change C.head-1  ≤  moveAt lineShift (M.action C.state (C.tape C.head)).2.2 C.head ∧
    moveAt lineShift (M.action C.state (C.tape C.head)).2.2 C.head  ≤  C.head+1
  rw [moveAt_line]
  cases (M.action C.state (C.tape C.head)).2.2 <;> simp [Move.displacement]
  omega

theorem line_head_run (w : List Bool) (t : ℕ) :
    -(t:ℤ)  ≤  (M.run lineShift (M.initial w) t).head ∧
      (M.run lineShift (M.initial w) t).head  ≤  (t:ℤ) := by
  induction t with
  | zero => simp [run,initial]
  | succ t ih =>
    have hs := M.line_head_step (M.run lineShift (M.initial w) t)
    change -(↑(t+1):ℤ)  ≤  ((M.step lineShift)^[t+1] (M.initial w)).head ∧
      ((M.step lineShift)^[t+1] (M.initial w)).head  ≤  (↑(t+1):ℤ)
    rw [Function.iterate_succ_apply']
    change -(↑(t+1):ℤ)  ≤  (M.step lineShift (M.run lineShift (M.initial w) t)).head ∧
      (M.step lineShift (M.run lineShift (M.initial w) t)).head  ≤  (↑(t+1):ℤ)
    push_cast
    omega

def Agrees {J : Type uJ} (π : ℤ → J) (I : Set ℤ) (C : M.Config ℤ) (D : M.Config J) : Prop :=
  D.state=C.state ∧ D.head=π C.head ∧ ∀ z∈I,D.tape (π z)=C.tape z

theorem agrees_step {J : Type uJ} (shift : Equiv.Perm J) (π : ℤ → J) (I : Set ℤ)
    (hπ : ∀ z,π (z+1)=shift (π z)) (hinj : Set.InjOn π I)
    (C : M.Config ℤ) (D : M.Config J) (ha : M.Agrees π I C D) (hh : C.head∈I) :
    M.Agrees π I (M.step lineShift C) (M.step shift D) := by
  classical
  obtain ⟨hs,hd,ht⟩ := ha
  have scanned : D.tape D.head=C.tape C.head := by rw [hd]; exact ht _ hh
  have moved (d : Move) : moveAt shift d (π C.head)=π (moveAt lineShift d C.head) := by
    rw [moveAt_line]
    cases d with
    | stay => simp [moveAt,Move.displacement]
    | right => exact (hπ C.head).symm
    | left =>
      change shift.symm (π C.head)=π (C.head+(-1))
      apply shift.injective
      rw [shift.apply_symm_apply,← hπ]
      congr 1
      omega
  refine ⟨?_,?_,?_⟩
  · simp only [step,hs,scanned]
  · simp only [step,hs,hd,ht _ hh,moved]
  · intro z hz
    simp only [step]
    rw [hs,scanned,hd]
    have he : π z=π C.head ↔ z=C.head := ⟨hinj hz hh,congrArg π⟩
    simp only [Function.update_apply,he]
    split <;> first | rfl | exact ht z hz

theorem agrees_run {J : Type uJ} (shift : Equiv.Perm J) (π : ℤ → J) (I : Set ℤ)
    (hπ : ∀ z,π (z+1)=shift (π z)) (hinj : Set.InjOn π I)
    (w : List Bool) (D : M.Config J) (ha : M.Agrees π I (M.initial w) D)
    (T : ℕ) (hI : ∀ z : ℤ, -(T:ℤ) ≤ z → z ≤ T → z∈I) :
    ∀ t ≤ T, M.Agrees π I (M.run lineShift (M.initial w) t) (M.run shift D t) := by
  intro t
  induction t with
  | zero => intro _; exact ha
  | succ t ih =>
    intro ht
    have hl := M.line_head_run w t
    have hi : (M.run lineShift (M.initial w) t).head∈I :=
      hI _ (by omega) (by omega)
    have hc := M.agrees_step shift π I hπ hinj _ _ (ih (by omega)) hi
    simpa only [run,Function.iterate_succ_apply'] using hc

theorem run_frozen_after {J : Type uJ} (shift : Equiv.Perm J) (C : M.Config J)
    (t : ℕ) (hh : (M.run shift C t).state.val=1 ∨ (M.run shift C t).state.val=2)
    (s : ℕ) (hts : t ≤ s) : M.run shift C s=M.run shift C t := by
  obtain ⟨u,rfl⟩ := Nat.exists_eq_add_of_le hts
  change (M.step shift)^[t+u] C = _
  rw [Nat.add_comm,Function.iterate_add_apply]
  exact M.run_halted shift (M.run shift C t) hh u

theorem accepts_iff_state (w : List Bool) (T : ℕ)
    (hh : (M.run lineShift (M.initial w) T).state.val=1 ∨
      (M.run lineShift (M.initial w) T).state.val=2) :
    M.toTM.accepts w ↔ (M.run lineShift (M.initial w) T).state.val=1 := by
  constructor
  · rintro ⟨s,hs⟩
    have hs' : (M.run lineShift (M.initial w) s).state.val=1 := by
      have he := congrArg (fun C : M.toTM.Config => C.state.val) (M.embed_run w s)
      exact he.trans hs
    rcases le_total s T with hst | hts
    · rw [M.run_frozen_after lineShift (M.initial w) s (Or.inl hs') T hst]
      exact hs'
    · rw [M.run_frozen_after lineShift (M.initial w) T hh s hts] at hs'
      exact hs'
  · intro hs
    refine ⟨T,?_⟩
    have he := congrArg (fun C : M.toTM.Config => C.state.val) (M.embed_run w T)
    exact he.symm.trans hs

def protectedInterval (m T : ℕ) : Set ℤ := Set.Icc (-(T:ℤ)-1) ((m:ℤ)+T)

theorem protectedInterval_injective (m T L : ℕ) (hL : 2*T+m+2< L) :
    Set.InjOn (fun z : ℤ => (z : ZMod L)) (protectedInterval m T) := by
  intro x hx y hy he
  have hd := (ZMod.intCast_eq_intCast_iff_dvd_sub x y L).mp he
  have hL' : (2*(T:ℤ)+m+2)< L := by exact_mod_cast hL
  change -(T:ℤ)-1 ≤ x ∧ x ≤ (m:ℤ)+T at hx
  change -(T:ℤ)-1 ≤ y ∧ y ≤ (m:ℤ)+T at hy
  rcases le_total x y with hxy | hyx
  · have hz : y-x=0 := Int.eq_zero_of_dvd_of_nonneg_of_lt (by omega) (by omega) hd
    omega
  · have hd' : (L:ℤ)∣x-y := by simpa only [neg_sub] using (dvd_neg.mpr hd)
    have hz : x-y=0 := Int.eq_zero_of_dvd_of_nonneg_of_lt (by omega) (by omega) hd'
    omega

def ringShift (L : ℕ) : Equiv.Perm (ZMod L) := Equiv.addRight 1

noncomputable def ringInitial (L : ℕ) (w : List Bool) : M.Config (ZMod L) where
  state := ⟨0,by have := M.states_ge; omega⟩
  head := 0
  tape j := if j.val< w.length then M.toTM.symbol (w.getD j.val false)
    else ⟨0,by have := M.symbols_ge; omega⟩

theorem ring_initial_agrees (w : List Bool) (T L : ℕ) (hL : 2*T+w.length+2< L) :
    M.Agrees (fun z : ℤ => (z : ZMod L)) (protectedInterval w.length T)
      (M.initial w) (M.ringInitial L w) := by
  classical
  have hp : 0< L := by omega
  let : NeZero L := ⟨Nat.ne_of_gt hp⟩
  refine ⟨rfl,by simp [ringInitial,initial],?_⟩
  intro z hz
  have hinj := protectedInterval_injective w.length T L hL
  have input_mem (i : ℕ) (hi : i< w.length) : (i:ℤ)∈protectedInterval w.length T := by
    change -(T:ℤ)-1 ≤ i ∧ (i:ℤ) ≤ (w.length:ℤ)+T
    constructor <;> omega
  have hi : (z : ZMod L).val< w.length ↔ 0 ≤ z ∧ z.toNat< w.length := by
    constructor
    · intro h
      have he : ((z : ZMod L).val : ℤ)=z := hinj (input_mem _ h) hz (by simp)
      rw [← he]
      simp only [Int.natCast_nonneg,Int.toNat_natCast,true_and]
      exact h
    · rintro ⟨hz0,hzlen⟩
      have he : (((z.toNat:ℕ):ℤ):ZMod L)=(z:ZMod L) := by rw [Int.toNat_of_nonneg hz0]
      have hsmall : z.toNat< L := by omega
      rw [← he]
      simpa only [Int.cast_natCast,ZMod.val_natCast,Nat.mod_eq_of_lt hsmall] using hzlen
  have hv (h : (z : ZMod L).val< w.length) : (z : ZMod L).val=z.toNat := by
    have he : ((z : ZMod L).val : ℤ)=z := hinj (input_mem _ h) hz (by simp)
    simpa only [Int.toNat_natCast] using congrArg Int.toNat he
  simp only [ringInitial,initial]
  by_cases hr : (z : ZMod L).val< w.length
  · simp [hi.mp hr,hv hr]
    rfl
  · simp [hr,show ¬(0 ≤ z ∧ z.toNat< w.length) from fun h => hr (hi.mpr h)]

theorem ring_run_agrees (w : List Bool) (T L : ℕ) (hL : 2*T+w.length+2< L) :
    ∀ t ≤ T,M.Agrees (fun z : ℤ => (z : ZMod L)) (protectedInterval w.length T)
      (M.run lineShift (M.initial w) t) (M.run (ringShift L) (M.ringInitial L w) t) := by
  apply M.agrees_run
  · intro z
    change ((z+1:ℤ):ZMod L)=(z:ZMod L)+1
    push_cast
    rfl
  · exact protectedInterval_injective w.length T L hL
  · exact M.ring_initial_agrees w T L hL
  · intro z hz0 hz1
    change -(T:ℤ)-1 ≤ z ∧ z ≤ (w.length:ℤ)+T
    constructor <;> omega

def letterAccepting (c : M.Cell) : Prop := ∃ q,c.2=some q ∧ q.val=1

theorem accepting_snapshot {J : Type uJ} (C : M.Config J) :
    (∃ j,M.letterAccepting (M.snapshot C j)) ↔ C.state.val=1 := by
  classical
  constructor
  · rintro ⟨j,q,hq,hv⟩
    by_cases hj : j=C.head
    · simp only [snapshot,hj,ite_true,Option.some.injEq] at hq
      exact hq ▸ hv
    · simp [snapshot,hj] at hq
  · intro hv
    exact ⟨C.head,C.state,by simp [snapshot],hv⟩

theorem ring_accepts_iff (w : List Bool) (T L S : ℕ)
    (hL : 2*T+w.length+2< L) (hTS : T ≤ S)
    (hh : (M.run lineShift (M.initial w) T).state.val=1 ∨
      (M.run lineShift (M.initial w) T).state.val=2) :
    (∃ j,M.letterAccepting (CircuitEncoding.Tableau.run M.localRule (ringShift L)
      (M.snapshot (M.ringInitial L w)) S j)) ↔ M.toTM.accepts w := by
  rw [← M.run_snapshot,M.accepting_snapshot,M.accepts_iff_state w T hh]
  have hA := M.ring_run_agrees w T L hL T le_rfl
  have hR : (M.run (ringShift L) (M.ringInitial L w) T).state.val=1 ∨
      (M.run (ringShift L) (M.ringInitial L w) T).state.val=2 := by rw [hA.1]; exact hh
  rw [M.run_frozen_after (ringShift L) (M.ringInitial L w) T hR S hTS,hA.1]

end OneTape
end WLTime

namespace WLTime.TM
variable (M : TM)

theorem run_add (w : List Bool) (a b : ℕ) :
    M.run w (a+b)=M.step^[a] (M.run w b) :=
  Function.iterate_add_apply _ _ _ _

theorem run_succ (w : List Bool) (t : ℕ) : M.run w (t+1)=M.step (M.run w t) :=
  Function.iterate_succ_apply' _ _ _

theorem step_frozen (C : M.Config) (h : M.halted C) : M.step C=C := by
  rw [step,ite_eq_left h]

theorem run_frozen (w : List Bool) {t u : ℕ} (hh : M.halted (M.run w t))
    (hu : t ≤ u) : M.run w u=M.run w t := by
  obtain ⟨a,rfl⟩ := Nat.exists_eq_add_of_le hu
  rw [Nat.add_comm,M.run_add]
  exact Function.iterate_fixed (M.step_frozen _ hh) a

theorem time_halted (w : List Bool) (h : M.halts w) : M.halted (M.run w (M.time w)) := by
  simp only [time,dite_eq_left h]
  exact Nat.find_spec h

theorem time_le_of_halted (w : List Bool) {t : ℕ} (h : M.halted (M.run w t)) : M.time w ≤ t := by
  have hh : M.halts w := ⟨t,h⟩
  simp only [time,dite_eq_left hh]
  exact Nat.find_min' hh h

theorem accepts_iff_at_halt (w : List Bool) {t : ℕ} (h : M.halted (M.run w t)) :
    M.accepts w ↔ (M.run w t).state.val=1 := by
  constructor
  · rintro ⟨s,hs⟩
    have hx := M.run_frozen w h (Nat.le_max_right s t)
    have hy := M.run_frozen w (Or.inl hs) (Nat.le_max_left s t)
    rw [hx] at hy
    exact congrArg (fun C : M.Config => C.state.val) hy |>.trans hs
  · intro ht; exact ⟨t,ht⟩

end WLTime.TM

end OAI