import Mathlib
import OAI.GroupTheory.SimpleOvergroups.EffectiveArrays
import OAI.GroupTheory.SimpleOvergroups.EnlargementNames
import OAI.GroupTheory.SimpleOvergroups.MatrixEffective
import OAI.GroupTheory.SimpleOvergroups.PlanEffective

namespace OAI


namespace SimpleFInftyOvergroups.EffectiveNames.Enlargement
open BoundedEncoding NamedAction
open BinaryPrefixOperators.Arithmetic
noncomputable section
open scoped Classical
variable {G X P k : Type*} [CommRing k] (N : Operations G X)
  (e : P → Coeff.Name k)
variable [Primcodable k]

def arrayKey {J : Type*} [Primcodable J] : (J →₀ D k) → ℕ :=
  semanticKey (Array.value Coeff.value id)
    (Array.value_surjective Coeff.value id Lists.value_surjective Function.surjective_id)

 theorem arrayKey_injective {J : Type*} [Primcodable J] :
    Function.Injective (arrayKey (k:=k) (J:=J)) := semanticKey_injective _ _

def pairedKey {J : Type*} [Primcodable J] (p : (J →₀ D k) × (J →₀ D k)) : ℕ × ℕ :=
  (arrayKey p.1,arrayKey p.2)

 theorem pairedKey_injective {J : Type*} [Primcodable J] :
    Function.Injective (pairedKey (k:=k) (J:=J)) := by
  intro p q h
  exact Prod.ext (arrayKey_injective (congrArg Prod.fst h)) (arrayKey_injective (congrArg Prod.snd h))

variable {V Y K L : Type*} [Group V] [MulAction V Y] [Nonempty Y] {m : ℕ}
  (C : ActionCalculus V Y K L m) [Primcodable K] [Primcodable L]

def calculus : ActionCalculus (MonoidAlgebra (D k) V)ˣ (Y →₀ D k) (ℕ × ℕ) ℕ m :=
  (C.enlargement (D k)).rekey pairedKey arrayKey pairedKey_injective arrayKey_injective

variable {C} (I : Interpretation N C)
  (he : ∀ p, Coeff.value (e p) * Coeff.value (e p) = Coeff.value (e p))

def groupLabel (w : Word P G) : (calculus (k:=k) C).GLabel :=
  ⟨groupValue N e I he w,gcost N w,group_mem N e I he w⟩
def pointLabel (x : Point P G X) : (calculus (k:=k) C).XLabel :=
  ⟨pointValue N e I he x,xcost N x,point_mem N e I he x⟩

def interpretation : Interpretation (operations (P:=P) N) (calculus (k:=k) C) where
  group := groupLabel N e I he
  point := pointLabel N e I he
  group_cost w := rfl
  point_cost x := rfl
  one := WithBound.ext' (groupValue_nil N e I he) rfl
  mul a b := WithBound.ext' (groupValue_append N e I he a b) (gcost_append N a b)
  inv w := WithBound.ext' (groupValue_inverse N e I he w) (gcost_inverse N w)
  act g x := WithBound.ext' (pointValue_act N e I he g x)
    (by change gcost N (g++x.1) + N.xcost x.2 = gcost N g + xcost N x
        simp [xcost,Nat.add_assoc])

variable [Primcodable G] [Primcodable X]

def partialGroupKey (f : G → Part K) (w : Word P G) : Part (ℕ × ℕ) :=
  (Array.collectedKey Coeff.value f (array N e w)).bind fun a =>
    (Array.collectedKey Coeff.value f (array N e (inverse N w))).map fun b => (a,b)

def partialPointKey (f : X → Part L) (x : Point P G X) : Part ℕ :=
  Array.collectedKey Coeff.value f (pointArray N e x)

omit [Primcodable G] [Primcodable X] in
 theorem partialGroupKey_full (f : G → Part K) (w : Word P G) {d : ℕ}
    (hw : gcost N w ≤ d) (hf : ∀ g, N.gcost g ≤ d → I.gkey g ∈ f g) :
    (interpretation N e I he).gkey w ∈ partialGroupKey N e f w := by
  have h (u : Word P G) (hu : gcost N u ≤ d) :=
    Array.collectedKey_full Coeff.value Lists.value_surjective f
      (fun g => (I.group g).val) C.group.key (array N e u)
      (fun a ha => hf a.2 ((array_bound N e u a ha).trans hu))
  have h' (u : Word P G) (hu : gcost N u ≤ d) :
      arrayKey (C.group.algebraCollect (D k) (groupValue N e I he u).val) ∈
        Array.collectedKey Coeff.value f (array N e u) := by
    have hh := h u hu
    have hv := congrArg MonoidAlgebra.coeff (value_array N e I he u)
    change Array.value Coeff.value (fun g => (I.group g).val) (array N e u) = _ at hv
    rw [hv] at hh
    exact hh
  change (arrayKey (C.group.algebraCollect (D k) (groupValue N e I he w).val),
    arrayKey (C.group.algebraCollect (D k) (groupValue N e I he w).inv)) ∈ _
  exact Part.mem_bind_iff.mpr ⟨_,h' w hw,Part.mem_map _ (by
    have hh := h' (inverse N w) (by simpa using hw)
    simpa only [groupValue_inverse, ← Units.inv_eq_val_inv] using hh)⟩

omit [Primcodable G] [Primcodable X] in
 theorem partialPointKey_full (f : X → Part L) (x : Point P G X) {d : ℕ}
    (hx : xcost N x ≤ d) (hf : ∀ y, N.xcost y ≤ d → I.xkey y ∈ f y) :
    (interpretation N e I he).xkey x ∈ partialPointKey N e f x := by
  have h := Array.collectedKey_full Coeff.value Lists.value_surjective f
    (fun y => (I.point y).val) C.point.key (pointArray N e x)
    (fun a ha => hf a.2 ((pointArray_bound N e x a ha).trans hx))
  rw [value_pointArray N e I he] at h
  exact h

variable [Primcodable P] [Finite P] [Finite k]

 theorem computable_array_eq {J : Type*} [Primcodable J] : ComputablePred
    (fun p : Array.Name (Coeff.Name k) J × Array.Name (Coeff.Name k) J =>
      Array.value Coeff.value id p.1 = Array.value Coeff.value id p.2) := by
  apply Array.computable_value_eq Coeff.value id [] (·++·) Primrec.list_append
    (show ComputablePred (fun p : J × J => p.1 = p.2) from Primrec.eq.computablePred)
    Lists.computable_value_eq
  · exact Lists.value_nil
  · exact Lists.value_append

omit [Primcodable X] [Finite P] in
 theorem primrec_inverse (hi : Primrec N.inv) : Primrec (inverse (P:=P) N) :=
  Primrec.list_map Primrec.list_reverse
    ((Primrec.fst.comp Primrec.snd).pair (hi.comp (Primrec.snd.comp Primrec.snd))).to₂

omit [Finite P] in
 theorem primrec_act : Primrec₂ ((operations (P:=P) N).act) :=
  (Primrec.list_append.comp Primrec.fst (Primrec.fst.comp Primrec.snd)).pair
    (Primrec.snd.comp Primrec.snd)

omit [Finite P] in
 theorem primrec_plan (hi : Primrec N.inv) : Primrec₂ ((operations (P:=P) N).plan) :=
  (operations N).primrec_plan Primrec.list_append (primrec_inverse N hi) (primrec_act N)

omit [Primcodable X] in
 theorem primrec_rootArray : Primrec (rootArray N e) := by
  have hc : Primrec (Coeff.complement (k:=k)) :=
    Primrec.list_append.comp (Primrec.const Coeff.one) Lists.primrec_negate
  have he : Primrec e := Primrec.dom_finite e
  exact Primrec.list_cons.comp
    ((hc.comp (he.comp Primrec.fst)).pair (Primrec.const N.one))
    (Primrec.list_cons.comp ((he.comp Primrec.fst).pair Primrec.snd) (Primrec.const []))

omit [Primcodable X] in
 theorem primrec_array (hm : Primrec₂ N.mul) : Primrec (array N e) :=
  Primrec.list_foldr Primrec.id (Primrec.const [(Coeff.one,N.one)])
    ((Array.primrec_product Lists.primrec_product hm).comp
      ((primrec_rootArray N e).comp (Primrec.fst.comp Primrec.snd))
      (Primrec.snd.comp Primrec.snd)).to₂

 theorem primrec_pointArray (hm : Primrec₂ N.mul) (hx : Primrec₂ N.act) :
    Primrec (pointArray N e) :=
  (Array.primrec_product Lists.primrec_product hx).comp
    ((primrec_array N e hm).comp Primrec.fst)
    (Primrec.list_cons.comp ((Primrec.const Coeff.one).pair Primrec.snd) (Primrec.const []))

omit [Primcodable X] [Finite P] in
 theorem primrec_gcost (hc : Primrec N.gcost) : Primrec (gcost (P:=P) N) := by
  have hs : Primrec (fun l : List ℕ => l.sum) :=
    (Primrec.list_foldr Primrec.id (Primrec.const 0)
      (Primrec.nat_add.comp (Primrec.fst.comp Primrec.snd) (Primrec.snd.comp Primrec.snd)).to₂).of_eq
      (fun _ => rfl)
  exact hs.comp (Primrec.list_map Primrec.id (hc.comp (Primrec.snd.comp Primrec.snd)).to₂)

omit [Finite P] in
 theorem primrec_xcost (hg : Primrec N.gcost) (hx : Primrec N.xcost) :
    Primrec (xcost (P:=P) N) :=
  Primrec.nat_add.comp ((primrec_gcost N hg).comp Primrec.fst) (hx.comp Primrec.snd)

variable {Param : Type*} [Primcodable Param]
variable {fg : Param → G → Part K} {fx : Param → X → Part L}

omit [Primcodable X] in
 theorem partrec_partialGroupKey (hm : Primrec₂ N.mul) (hi : Primrec N.inv)
    (hf : Partrec₂ fg) : Partrec₂ (fun p : Param => partialGroupKey N e (fg p)) := by
  have hp : Partrec (fun p : Param × Word P G =>
      Array.collectedKey Coeff.value (fg p.1) (array N e p.2)) :=
    (Array.partrec_collectedKey Coeff.value computable_array_eq hf).comp Computable.fst
      ((primrec_array N e hm).to_comp.comp Computable.snd)
  apply hp.bind
  have hq : Partrec (fun p : (Param × Word P G) × ℕ =>
      Array.collectedKey Coeff.value (fg p.1.1) (array N e (inverse N p.1.2))) :=
    (Array.partrec_collectedKey Coeff.value computable_array_eq hf).comp (Computable.fst.comp Computable.fst)
      ((primrec_array N e hm).to_comp.comp ((primrec_inverse N hi).to_comp.comp
        (Computable.snd.comp Computable.fst)))
  exact (hq.map ((Computable.snd.comp Computable.fst).pair Computable.snd).to₂).to₂

 theorem partrec_partialPointKey (hm : Primrec₂ N.mul) (hx : Primrec₂ N.act)
    (hf : Partrec₂ fx) : Partrec₂ (fun p : Param => partialPointKey N e (fx p)) :=
  (Array.partrec_collectedKey Coeff.value computable_array_eq hf).comp Computable.fst
    ((primrec_pointArray N e hm hx).to_comp.comp Computable.snd)


end
end SimpleFInftyOvergroups.EffectiveNames.Enlargement

end OAI