import Mathlib
import OAI.GroupTheory.SimpleOvergroups.PolynomialNames

namespace OAI


namespace SimpleFInftyOvergroups.EffectiveNames.Polynomial
open BoundedEncoding
noncomputable section
open scoped Classical
variable {A k : Type*} [CommSemiring k]

omit [CommSemiring k] in
@[simp] theorem cost_nil (grade : List A → ℕ) : cost grade ([] : Name k A) = 0 := rfl

omit [CommSemiring k] in
 theorem cost_append (grade : List A → ℕ) (p q : Name k A) :
    cost grade (p++q) = max (cost grade p) (cost grade q) := by
  apply Nat.le_antisymm
  · rw [cost_le_iff]
    intro a ha
    rcases List.mem_append.mp ha with ha | ha
    · exact (term_cost_le grade ha).trans (Nat.le_max_left _ _)
    · exact (term_cost_le grade ha).trans (Nat.le_max_right _ _)
  · rw [max_le_iff, cost_le_iff, cost_le_iff]
    exact ⟨fun a ha => term_cost_le grade (List.mem_append_left _ ha),
      fun a ha => term_cost_le grade (List.mem_append_right _ ha)⟩

 theorem value_flatten (ps : List (Name k A)) : value ps.flatten = (ps.map value).sum := by
  induction ps with
  | nil => rfl
  | cons p ps ih => simp [ih]

omit [CommSemiring k] in
 theorem cost_flatten_le (grade : List A → ℕ) {ps : List (Name k A)} {b : ℕ}
    (h : ∀ p ∈ ps, cost grade p ≤ b) : cost grade ps.flatten ≤ b := by
  rw [cost_le_iff]
  intro a ha
  obtain ⟨p,hp,ha⟩ := List.mem_flatten.mp ha
  exact (term_cost_le grade ha).trans (h p hp)

 theorem cost_product_le (grade : List A → ℕ)
    (ha : ∀ u v, grade (u++v) = grade u + grade v) (p q : Name k A) :
    cost grade (product p q) ≤ cost grade p + cost grade q := by
  rw [cost_le_iff]
  intro x hx
  obtain ⟨a,ha',hx⟩ := List.mem_flatMap.mp hx
  obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hx
  rw [ha]
  exact Nat.add_le_add (term_cost_le grade ha') (term_cost_le grade hb)

 theorem cost_oneName (grade : List A → ℕ) (h0 : grade [] = 0) :
    cost grade (oneName : Name k A) = 0 := by simp [oneName,cost,h0]

variable {R : Type*} [CommRing R]
def negate (p : Name R A) : Name R A := p.map (fun a => (-a.1,a.2))

@[simp] theorem value_negate (p : Name R A) : value (negate p) = -value p := by
  induction p with
  | nil => simp [negate]
  | cons a p ih =>
    change MonoidAlgebra.single (FreeMonoid.ofList a.2) (-a.1) + value (negate p) =
      -(MonoidAlgebra.single (FreeMonoid.ofList a.2) a.1 + value p)
    rw [MonoidAlgebra.single_neg,ih]
    abel

@[simp] theorem cost_negate (grade : List A → ℕ) (p : Name R A) :
    cost grade (negate p) = cost grade p := by
  simp only [negate,cost,List.map_map,Function.comp_def]

 theorem primrec_negate [Primcodable A] [Primcodable R] [Finite R] :
    Primrec (negate (R:=R) (A:=A)) := by
  exact Primrec.list_map Primrec.id
    (((Primrec.dom_finite (Neg.neg : R → R)).comp (Primrec.fst.comp Primrec.snd)).pair
      (Primrec.snd.comp Primrec.snd)).to₂
end
end SimpleFInftyOvergroups.EffectiveNames.Polynomial

end OAI