import OAI.Computability.StarHeight.EpisodeHeight

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uM uAlphabet2 uM2

namespace RightRegular

open EpisodeAlgebra
open scoped Computability
variable {Alphabet : Type uAlphabet} {M : Type uM} [Monoid M] [Fintype M]

lemma updateWord_product (T : FreeMonoid Alphabet →* M)
    (es : List (List Alphabet)) (x : V M) :
    updateWord (fun w => action M (T (FreeMonoid.ofList w))) x es =
      action M (T (FreeMonoid.ofList es.flatten)) x := by
  induction es generalizing x with
  | nil =>
    change x=action M (T 1) x
    rw [map_one,action_one]
    rfl
  | cons e es ih =>
    rw [updateWord_cons,ih]
    change action M (T (FreeMonoid.ofList es.flatten))
      (action M (T (FreeMonoid.ofList e)) x) =
      action M (T (FreeMonoid.ofList e * FreeMonoid.ofList es.flatten)) x
    rw [map_mul,action_mul]
    rfl

lemma graph_fiber (T : FreeMonoid Alphabet →* M) (E : Language Alphabet) (d : M) :
    graph E (fun w => action M (T (FreeMonoid.ofList w))) (basis M 1) (basis M d) =
      ({w | w∈E∗ ∧ T (FreeMonoid.ofList w)=d} : Language Alphabet) := by
  ext w
  constructor
  · rintro ⟨es,hes,rfl,h⟩
    refine ⟨Language.join_mem_kstar hes,?_⟩
    rw [updateWord_product] at h
    exact (value_recovery M _ _).mp h
  · rintro ⟨hw,hd⟩
    obtain ⟨es,rfl,hes⟩ := Language.mem_kstar.mp hw
    refine ⟨es,hes,rfl,?_⟩
    rw [updateWord_product]
    exact (value_recovery M _ _).mpr hd

end RightRegular

namespace FiniteRecognition

open EpisodeAlgebra
open scoped Computability

theorem recognized_height_three {Alphabet : Type uAlphabet2} {M : Type uM2} [Finite Alphabet] [Nonempty Alphabet]
    [Monoid M] [Fintype M] (T : FreeMonoid Alphabet →* M) (F : Set M) :
    HasHeightAtMost ({w | T (FreeMonoid.ofList w)∈F} : Language Alphabet) 3 := by
  classical
  obtain ⟨E,hE,hB,hG⟩ := SourceSchedule.episode_linear_graphs T (RightRegular.action M)
  let A : M → Language Alphabet := fun d => {w | w∈E∗ ∧ T (FreeMonoid.ofList w)=d}
  let B : M → Language Alphabet := fun f => {w | w∈remainder E ∧ T (FreeMonoid.ofList w)=f}
  have hA : ∀ d, HasHeightAtMost (A d) 3 := by
    intro d
    change HasHeightAtMost ({w | w∈E∗ ∧ T (FreeMonoid.ofList w)=d} : Language Alphabet) 3
    rw [←RightRegular.graph_fiber T E d]
    exact hG (RightRegular.basis M 1) (RightRegular.basis M d)
  let I := {p : M × M // p.1*p.2∈F}
  have hU : HasHeightAtMost (⨆ p : I, A p.1.1 * B p.1.2) 3 :=
    HasHeightAtMost.iSup _ (fun p => (hA p.1.1).concat ((hB p.1.2).mono (by decide)))
  have heq : ({w | T (FreeMonoid.ofList w)∈F} : Language Alphabet)=
      ⨆ p : I, A p.1.1 * B p.1.2 := by
    ext w
    constructor
    · intro hw
      obtain ⟨es,r,hes,hr,hwr⟩ := factor_remainder hE.1 w
      let d := T (FreeMonoid.ofList es.flatten)
      let f := T (FreeMonoid.ofList r)
      have hdf : d*f∈F := by
        change T (FreeMonoid.ofList es.flatten)*T (FreeMonoid.ofList r)∈F
        rw [←map_mul]
        change T (FreeMonoid.ofList (es.flatten++r))∈F
        rw [←hwr]
        exact hw
      apply Language.mem_iSup.mpr
      refine ⟨⟨(d,f),hdf⟩,Language.mem_mul.mpr ⟨es.flatten,?_,r,?_,hwr.symm⟩⟩
      · exact ⟨Language.join_mem_kstar hes,rfl⟩
      · exact ⟨hr,rfl⟩
    · intro hw
      obtain ⟨p,hp⟩ := Language.mem_iSup.mp hw
      obtain ⟨a,ha,b,hb,rfl⟩ := Language.mem_mul.mp hp
      change T (FreeMonoid.ofList a * FreeMonoid.ofList b)∈F
      rw [map_mul,ha.2,hb.2]
      exact p.2
  exact heq.symm ▸ hU

end FiniteRecognition

end GeneralizedStarHeight

end OAI