import OAI.Computability.StarHeight.Episodes

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uS uM uK uS2

namespace AffineRecovery

open scoped Computability
open EpisodeAlgebra

variable {Alphabet : Type u} {S : Type uS} [AddCommGroup S]

def affine (L : List Alphabet → S →+ S) (b : List Alphabet → S)
    (e : List Alphabet) (x : S) : S := L e x + b e

lemma update_add (L : List Alphabet → S →+ S) (b : List Alphabet → S)
    (es : List (List Alphabet)) (x z : S) :
    updateWord (affine L b) (x + z) es =
      updateWord (fun e => L e) x es + updateWord (affine L b) z es := by
  induction es generalizing x z with
  | nil => rfl
  | cons e es ih =>
      simp only [updateWord_cons]
      have hh : affine L b e (x + z) = L e x + affine L b e z := by
        simp only [affine, map_add, add_assoc]
      rw [hh, ih]

lemma update_eq_linear_add (L : List Alphabet → S →+ S) (b : List Alphabet → S)
    (es : List (List Alphabet)) (x : S) :
    updateWord (affine L b) x es =
      updateWord (fun e => L e) x es + updateWord (affine L b) 0 es := by
  simpa only [add_zero] using update_add L b es x 0

theorem recovery {E D : Language Alphabet} (hE : PrefixCode E) (hDE : D ≤ E)
    (L : List Alphabet → S →+ S) (b : List Alphabet → S) (x y : S) :
    graph D (fun e => L e) x y =
      ⨆ c : S, graph D (affine L b) x (y + c) ⊓ graph D (affine L b) 0 c := by
  ext w
  rw [Language.mem_iSup]
  constructor
  · rintro ⟨es, he, rfl, hxy⟩
    refine ⟨updateWord (affine L b) 0 es, ⟨es, he, rfl, ?_⟩, es, he, rfl, rfl⟩
    rw [update_eq_linear_add, hxy]
  · rintro ⟨c, ⟨es, he, hw, hx⟩, fs, hf, hfw, hzero⟩
    have hef := flatten_injective hE (he.mono hDE) (hf.mono hDE) (hw.trans hfw.symm)
    subst fs
    refine ⟨es, he, hw, ?_⟩
    rw [update_eq_linear_add, hzero] at hx
    exact add_right_cancel hx

theorem recovery_height [Finite S] {E D : Language Alphabet}
    (hE : PrefixCode E) (hDE : D ≤ E)
    (L : List Alphabet → S →+ S) (b : List Alphabet → S) (H : ℕ)
    (hG : ∀ x y, HasHeightAtMost (graph D (affine L b) x y) H) (x y : S) :
    HasHeightAtMost (graph D (fun e => L e) x y) H := by
  rw [recovery hE hDE L b]
  exact HasHeightAtMost.iSup _ (fun c => (hG x (y + c)).inter (hG 0 c))

end AffineRecovery

namespace RightRegular

variable (M : Type uM) [Monoid M] [Finite M]

abbrev V := M → ZMod 2

noncomputable def basis : Module.Basis M (ZMod 2) (V M) := Pi.basisFun (ZMod 2) M

noncomputable def action (d : M) : V M →ₗ[ZMod 2] V M :=
  (basis M).constr (ZMod 2) (fun m => basis M (m * d))

@[simp] lemma action_basis (d m : M) : action M d (basis M m) = basis M (m * d) := by
  simp only [action, Module.Basis.constr_basis]

@[simp] lemma action_one : action M 1 = LinearMap.id := by
  apply (basis M).ext
  intro m
  simp

lemma action_mul (d e : M) : action M (d * e) = (action M e).comp (action M d) := by
  apply (basis M).ext
  intro m
  simp [mul_assoc]

omit [Monoid M] in
lemma basis_injective : Function.Injective (basis M) := (basis M).injective

lemma action_faithful : Function.Injective (action M) := by
  intro d e h
  have hh := LinearMap.congr_fun h (basis M 1)
  simp only [action_basis, one_mul] at hh
  exact basis_injective M hh

lemma value_recovery (d e : M) : action M d (basis M 1) = basis M e ↔ d = e := by
  simp only [action_basis, one_mul, (basis_injective M).eq_iff]

end RightRegular

namespace Homogenization

variable {K : Type uK} {S : Type uS2} [CommSemiring K] [AddCommMonoid S] [Module K S]

def lift (L : S →ₗ[K] S) (b : S) : (S × K) →ₗ[K] (S × K) where
  toFun u := (L u.1 + u.2 • b, u.2)
  map_add' u v := by
    ext <;> simp [add_smul, add_assoc, add_comm, add_left_comm]
  map_smul' a u := by
    ext <;> simp [smul_add, smul_smul]

@[simp] lemma lift_apply_one (L : S →ₗ[K] S) (b : S) (x : S) :
    lift L b (x, 1) = (L x + b, 1) := by simp [lift]

@[simp] lemma lift_apply_zero (L : S →ₗ[K] S) (b : S) (x : S) :
    lift L b (x, 0) = (L x, 0) := by simp [lift]

lemma lift_comp (L A : S →ₗ[K] S) (b c : S) :
    (lift A c).comp (lift L b) = lift (A.comp L) (A b + c) := by
  ext u <;> simp [lift, smul_add]

end Homogenization

end GeneralizedStarHeight

end OAI