import OAI.Combinatorics.Automata.Diagrams
import OAI.Combinatorics.Automata.Syntactic

namespace OAI

namespace OneWayLiveness

/-- The scanned cells are the two fixed markers surrounding the ordinary word. -/
lemma scanned_list {Alpha : Type} (w : List Alpha) :
    List.ofFn (scanned w) = Symbol.left :: (w.map Symbol.letter ++ [Symbol.right]) := by
  rw [List.ofFn_succ]
  have hleft : scanned w (0 : Fin (w.length+2)) = .left := by simp [scanned]
  rw [hleft, List.ofFn_succ']
  congr 1
  have hre : scanned w (Fin.last (w.length)).succ = .right :=
    (scanned_eq_right_iff _ _).mpr rfl
  rw [hre, List.concat_eq_append]
  congr 1
  apply List.ext_getElem
  · simp
  · intro i hi hj
    simp only [List.length_ofFn] at hi
    simp only [List.getElem_ofFn, List.getElem_map]
    simp [scanned, show i+1 < w.length+1 by omega]

namespace CellNetwork
variable {Alpha Q : Type} [Fintype Q] (M : Machine Alpha Q)

lemma fullDiagram_markers (finish : Q) (w : List Alpha) :
    fullDiagram M finish w =
      bodyDiagram M finish .left * (w.map (fun a => bodyDiagram M finish (.letter a))).prod *
        bodyDiagram M finish .right := by
  unfold fullDiagram
  have h : (List.ofFn fun i : Fin (w.length+2) => bodyDiagram M finish (scanned w i)) =
      (List.ofFn (scanned w)).map (bodyDiagram M finish) := by rw [List.map_ofFn]; rfl
  rw [h, scanned_list]
  simp only [List.map_cons, List.map_append, List.map_nil, List.map_map,
    List.prod_cons, List.prod_append, List.prod_nil, mul_one, Function.comp_def, mul_assoc]

noncomputable def recognitionTest (finish : Q) (a : Pairing (Port Q ⊕ Port Q)) : Prop :=
  ¬ ∃ l r, (bodyDiagram M finish .left * a * bodyDiagram M finish .right).Compatible
    (Sum.elim l r) ∧ Separated M finish l r

lemma recognitionTest_iff (finish : Q) (ht : M.transition finish .right = none)
    (w : List Alpha) :
    recognitionTest M finish (w.map (fun a => bodyDiagram M finish (.letter a))).prod ↔
      Relation.ReflTransGen (M.Step w) (outCell w.length false,M.initial)
        (outCell w.length true,finish) := by
  rw [recognitionTest, ← fullDiagram_markers]
  exact diagram_recognizes_reach M finish ht w

end CellNetwork

namespace Machine
variable {H Q : Type} [Fintype H] [Fintype Q] (M : Machine (BRel H) Q)

lemma liveness_rank_bound (hM : ∀ w, M.Accepts false w ↔ BRel.live w)
    (x y : H) (hxy : x ≠ y) : rankLoss (Fintype.card H) ≤ 4 * (Fintype.card Q + 1)^2 := by
  classical
  let S := M.sinkCopy
  have ht : S.transition none .right = none := rfl
  have hr (w : List (BRel H)) :
      CellNetwork.recognitionTest S none
        (w.map (fun a => CellNetwork.bodyDiagram S none (.letter a))).prod ↔ BRel.live w := by
    rw [CellNetwork.recognitionTest_iff S none ht]
    exact (M.sinkCopy_accepts w).trans (hM w)
  have hb := matching_recognition_degree
    (fun a => CellNetwork.bodyDiagram S none (.letter a))
    (CellNetwork.recognitionTest S none) hr x y hxy
  have hc : Fintype.card (CellNetwork.Port (Option Q)) = 4 * (Fintype.card Q + 1)^2 := by
    simp only [CellNetwork.Port, CellNetwork.Slot, Fintype.card_prod, Fintype.card_bool,
      Fintype.card_option]
    ring
  rwa [hc] at hb

end Machine

/-- The representation uses four ports per ordered state pair. One sink state
suffices under reflexive acceptance; a fresh initial row handles positive runs. -/
theorem deterministic_lower_bound (h : ℕ) (hh : 2 ≤ h) (positive : Bool) (s : ℕ)
    (D : DMachine (Alphabet h) s) (hD : D.Recognizes positive (OWL h)) :
    2 ^ ((h - 2) / 31) ≤ 4 * (s + if positive then 2 else 1)^2 := by
  let x : Fin h := ⟨0, by omega⟩
  let y : Fin h := ⟨1, by omega⟩
  have hxy : x ≠ y := by intro he; have := congrArg Fin.val he; simp [x,y] at this
  cases positive with
  | false =>
    have hb := D.toMachine.liveness_rank_bound hD x y hxy
    simpa only [rankLoss, Fintype.card_fin, Bool.false_eq_true, ↓reduceIte] using hb
  | true =>
    have hd (w) : D.toMachine.positiveCopy.Accepts false w ↔ BRel.live w :=
      (D.toMachine.positiveCopy_accepts w).trans (hD w)
    have hb := D.toMachine.positiveCopy.liveness_rank_bound hd x y hxy
    simpa only [rankLoss, Fintype.card_fin, Fintype.card_option, ↓reduceIte,
      Nat.add_assoc] using hb

end OneWayLiveness

end OAI