import OAI.Combinatorics.Automata.Normalization

namespace OAI

namespace OneWayLiveness

/-- A nondeterministic automaton on an arbitrary state type. -/
structure NMachineOn (Alpha Q : Type) where
  initial : Q
  accepting : Set Q
  transition : Q → Symbol Alpha → Set (Q × Move)
  left_boundary : ∀ q q', (q', .left) ∉ transition q .left
  right_boundary : ∀ q q', (q', .right) ∉ transition q .right

namespace NMachineOn
variable {Alpha Q : Type} (M : NMachineOn Alpha Q)
abbrev Config (w : List Alpha) := Fin (w.length+2) × Q

def Step (w : List Alpha) (c c' : Config (Q := Q) w) : Prop :=
  ∃ d, (c'.2,d) ∈ M.transition c.2 (scanned w c.1) ∧ d.Rel c.1.val c'.1.val

def Accepts (positive : Bool) (w : List Alpha) : Prop :=
  ∃ c, FiniteRun positive (M.Step w) (⟨0,by omega⟩,M.initial) c ∧ c.2 ∈ M.accepting

def relabel {n : ℕ} (e : Q ≃ Fin n) : NMachine Alpha n where
  initial := e M.initial
  accepting := {q | e.symm q ∈ M.accepting}
  transition q b := {p | (e.symm p.1,p.2) ∈ M.transition (e.symm q) b}
  left_boundary q q' := M.left_boundary (e.symm q) (e.symm q')
  right_boundary q q' := M.right_boundary (e.symm q) (e.symm q')

lemma relabel_accepts {n : ℕ} (e : Q ≃ Fin n) (positive : Bool) (w : List Alpha) :
    (M.relabel e).Accepts positive w ↔ M.Accepts positive w := by
  have hfor {c c' : Fin (w.length+2) × Fin n} (hs : (M.relabel e).Step w c c') :
      M.Step w (c.1,e.symm c.2) (c'.1,e.symm c'.2) := hs
  have hback {c c' : Config (Q := Q) w} (hs : M.Step w c c') :
      (M.relabel e).Step w (c.1,e c.2) (c'.1,e c'.2) := by
    simpa only [NMachine.Step, Step, relabel, Set.mem_ofPred_eq, Equiv.symm_apply_apply] using hs
  unfold NMachine.Accepts Accepts
  constructor
  · rintro ⟨c,hc,ha⟩
    refine ⟨(c.1,e.symm c.2),?_,ha⟩
    cases positive <;> simp only [FiniteRun, Bool.false_eq_true, ↓reduceIte] at hc ⊢
    · simpa only [Function.onFun, relabel, Equiv.symm_apply_apply] using
        hc.lift (fun c => (c.1,e.symm c.2)) (fun _ _ h => hfor h)
    · simpa only [Function.onFun, relabel, Equiv.symm_apply_apply] using
        hc.lift (fun c => (c.1,e.symm c.2)) (fun _ _ h => hfor h)
  · rintro ⟨c,hc,ha⟩
    refine ⟨(c.1,e c.2),?_,by simpa only [relabel, Set.mem_ofPred_eq, Equiv.symm_apply_apply] using ha⟩
    cases positive <;> simp only [FiniteRun, Bool.false_eq_true, ↓reduceIte] at hc ⊢
    · exact hc.lift (fun c => (c.1,e c.2)) (fun _ _ h => hback h)
    · exact hc.lift (fun c => (c.1,e c.2)) (fun _ _ h => hback h)

lemma relabel_noLeft {n : ℕ} (e : Q ≃ Fin n)
    (hm : ∀ q b q', (q',.left) ∉ M.transition q b) : (M.relabel e).NoLeft :=
  fun q b q' => hm (e.symm q) b (e.symm q')
end NMachineOn

namespace PathNFA
variable {H : Type}
/-- `none` is the initial state. Boolean states are accept and reject. -/
abbrev State (H : Type) := Option (H ⊕ Bool)
abbrev path (p : H) : State H := some (.inl p)
abbrev accept : State H := some (.inr false)

def rules : State H → Symbol (BRel H) → Set (State H × Move)
  | none, .left => {c | ∃ p, c = (path p,.right)}
  | some (.inl p), .letter R => {c | ∃ q, c = (path q,.right) ∧ R.holds p q}
  | some (.inl _), .right => {(accept,.stay)}
  | _, _ => ∅

lemma rules_noLeft (q : State H) (b : Symbol (BRel H)) (q' : State H) :
    (q',.left) ∉ rules q b := by
  cases q with
  | none => cases b <;> simp [rules]
  | some q => cases q with
    | inl p => cases b <;> simp [rules]
    | inr b' => cases b <;> simp [rules]

def machine : NMachineOn (BRel H) (State H) where
  initial := none
  accepting := {accept}
  transition := rules
  left_boundary q q' := rules_noLeft q .left q'
  right_boundary q q' := by
    cases q with
    | none => simp [rules]
    | some q => cases q <;> simp [rules]

/-- A numbered path through a product, extended arbitrarily after its endpoint. -/
lemma product_path (w : List (BRel H)) (a b : H) :
    w.prod.holds a b ↔ ∃ p : ℕ → H, p 0 = a ∧ p w.length = b ∧
      ∀ i (hi : i < w.length), w[i].holds (p i) (p (i+1)) := by
  induction w generalizing a with
  | nil =>
    simp only [List.prod_nil, BRel.one_holds, List.length_nil, Nat.not_lt_zero, IsEmpty.forall_iff,
      implies_true, and_true]
    constructor
    · intro h; exact ⟨fun _ => a,rfl,h⟩
    · rintro ⟨p,hp,hq⟩; exact hp.symm.trans hq
  | cons R w ih =>
    simp only [List.prod_cons, BRel.mul_holds]
    constructor
    · rintro ⟨c,hR,hc⟩
      obtain ⟨p,hp,hb,hs⟩ := (ih c).mp hc
      let q : ℕ → H := fun i => match i with | 0 => a | i+1 => p i
      refine ⟨q,rfl,hb,?_⟩
      intro i hi
      cases i with
      | zero => simpa only [q, List.getElem_cons_zero, hp] using hR
      | succ i => exact hs i (by simpa using hi)
    · rintro ⟨p,hp,hb,hs⟩
      refine ⟨p 1,?_,(ih (p 1)).mpr ⟨fun i => p (i+1),rfl,hb,?_⟩⟩
      · rw [← hp]; exact hs 0 (by simp)
      · intro i hi
        exact hs (i+1) (by simpa using hi)

/-- The accumulated product on every prefix reached by a path state. -/
def Good (w : List (BRel H)) (c : NMachineOn.Config (Q := State H) w) : Prop :=
  match c.2 with
  | none => c.1.val = 0
  | some (.inl p) => 1 ≤ c.1.val ∧ ∃ a, (w.take (c.1.val-1)).prod.holds a p
  | some (.inr false) => BRel.live w
  | some (.inr true) => False

lemma scanned_letter_data (w : List (BRel H)) (i : Fin (w.length+2)) (R : BRel H)
    (hs : scanned w i = .letter R) : ∃ hi : i.val-1 < w.length, w[i.val-1] = R := by
  unfold scanned at hs
  split_ifs at hs with h0 hi
  exact ⟨by omega, Symbol.letter.inj hs⟩

lemma scanned_letter_cell (w : List (BRel H)) (i : ℕ) (hi : i < w.length) :
    scanned w ⟨i+1,by omega⟩ = .letter w[i] := by
  simp [scanned, show i+1 < w.length+1 by omega]

lemma good_step (w : List (BRel H)) (c c' : NMachineOn.Config (Q := State H) w)
    (hg : Good w c) (hs : machine.Step w c c') : Good w c' := by
  rcases c with ⟨i,q⟩
  rcases c' with ⟨j,r⟩
  rcases hs with ⟨d,hd,hm⟩
  change (r,d) ∈ rules q (scanned w i) at hd
  cases q with
  | none =>
    change i.val = 0 at hg
    cases hb : scanned w i with
    | left =>
      rw [hb] at hd
      obtain ⟨p,he⟩ := hd
      have hr := congrArg Prod.fst he
      have hdir := congrArg Prod.snd he
      dsimp only at hr hdir
      subst r d
      change j.val = i.val+1 at hm
      change 1 ≤ j.val ∧ ∃ a, (w.take (j.val-1)).prod.holds a p
      refine ⟨by omega,p,?_⟩
      simp [show j.val-1 = 0 by omega]
    | letter R => simp [hb,rules] at hd
    | right => simp [hb,rules] at hd
  | some q =>
    cases q with
    | inl p =>
      obtain ⟨hip,a,ha⟩ := hg
      change 1 ≤ i.val at hip
      change (w.take (i.val-1)).prod.holds a p at ha
      cases hb : scanned w i with
      | left => simp [hb,rules] at hd
      | letter R =>
        rw [hb] at hd
        obtain ⟨q,he,hR⟩ := hd
        have hr := congrArg Prod.fst he
        have hdir := congrArg Prod.snd he
        dsimp only at hr hdir
        subst r d
        change j.val = i.val+1 at hm
        obtain ⟨hi,hRi⟩ := scanned_letter_data w i R hb
        change 1 ≤ j.val ∧ ∃ a, (w.take (j.val-1)).prod.holds a q
        refine ⟨by omega,a,?_⟩
        rw [show j.val-1 = (i.val-1)+1 by omega, List.take_succ_eq_append_getElem hi]
        simp only [List.prod_append, List.prod_cons, List.prod_nil, mul_one, BRel.mul_holds]
        exact ⟨p,ha,hRi ▸ hR⟩
      | right =>
        rw [hb] at hd
        have he : (r,d) = (accept,.stay) := hd
        have hr := congrArg Prod.fst he
        dsimp only at hr
        subst r
        change BRel.live w
        have hi := (scanned_eq_right_iff w i).mp hb
        exact ⟨a,p,by simpa only [hi,Nat.add_sub_cancel,List.take_length] using ha⟩
    | inr b => cases hb : scanned w i <;> simp [rules] at hd

lemma accepts_iff (positive : Bool) (w : List (BRel H)) :
    machine.Accepts positive w ↔ BRel.live w := by
  constructor
  · rintro ⟨c,hc,ha⟩
    have hr : Relation.ReflTransGen (machine.Step w) (⟨0,by omega⟩,none) c := by
      cases positive with
      | false => exact hc
      | true => exact hc.to_reflTransGen
    have hg : Good w c := by
      clear hc ha
      induction hr with
      | refl => rfl
      | @tail c d hcd hstep ih => exact good_step w c d ih hstep
    have hac : c.2 = accept := ha
    simpa only [Good,hac] using hg
  · rintro ⟨a,b,hprod⟩
    obtain ⟨p,_hp,_hb,hpath⟩ := (product_path w a b).mp hprod
    let cell (i : ℕ) (hi : i ≤ w.length) : NMachineOn.Config (Q := State H) w :=
      (⟨i+1,by omega⟩,path (p i))
    have reach (i : ℕ) (hi : i ≤ w.length) :
        Relation.ReflTransGen (machine.Step w) (cell 0 (by omega)) (cell i hi) := by
      induction i with
      | zero => exact .refl
      | succ i ih =>
        refine (ih (by omega)).tail ?_
        refine ⟨.right,?_,rfl⟩
        change (path (p (i+1)),.right) ∈ rules (path (p i)) (scanned w ⟨i+1,by omega⟩)
        rw [scanned_letter_cell w i (by omega)]
        exact ⟨p (i+1),rfl,hpath i (by omega)⟩
    have first : machine.Step w (⟨0,by omega⟩,none) (cell 0 (by omega)) := by
      refine ⟨.right,?_,rfl⟩
      change (path (p 0),.right) ∈ rules none (scanned w 0)
      simp only [scanned, Fin.val_zero, ↓reduceDIte]
      exact ⟨p 0,rfl⟩
    let last : NMachineOn.Config (Q := State H) w := (⟨w.length+1,by omega⟩,accept)
    have final : machine.Step w (cell w.length le_rfl) last := by
      refine ⟨.stay,?_,rfl⟩
      change (accept,.stay) ∈ rules (path (p w.length)) (scanned w ⟨w.length+1,by omega⟩)
      rw [(scanned_eq_right_iff _ _).mpr rfl]
      exact Set.mem_singleton _
    have hp : Relation.TransGen (machine.Step w) (⟨0,by omega⟩,none) last :=
      (Relation.TransGen.head' first (reach w.length le_rfl)).tail final
    refine ⟨last,?_,rfl⟩
    cases positive with
    | false => exact hp.to_reflTransGen
    | true => exact hp

end PathNFA

/-- The explicit path automaton has h+3 states, including the unused rejector.
It accepts only after at least two transitions, so both conventions agree. -/
theorem small_nfa (h : ℕ) :
    ∃ N : NMachine (Alphabet h) (h+3), N.NoLeft ∧
      ∀ positive : Bool, N.Recognizes positive (OWL h) := by
  classical
  let e : PathNFA.State (Fin h) ≃ Fin (h+3) := Fintype.equivFinOfCardEq (by
    simp only [PathNFA.State, Fintype.card_option, Fintype.card_sum, Fintype.card_fin,
      Fintype.card_bool])
  refine ⟨PathNFA.machine.relabel e, PathNFA.machine.relabel_noLeft e PathNFA.rules_noLeft, ?_⟩
  intro positive w
  exact (PathNFA.machine.relabel_accepts e positive w).trans (PathNFA.accepts_iff positive w)

end OneWayLiveness

end OAI