import OAI.Algebra.DepthFive.Basic

namespace OAI

noncomputable section
universe u v w

namespace Problem335

namespace D5Leaf

def mapCoefficients {K : Type u} {L : Type v} {n : ℕ}
    (f : K → L) : D5Leaf K n → D5Leaf L n
  | .scalar a => .scalar (f a)
  | .variable x => .variable x

@[simp] theorem degree_mapCoefficients {K : Type u} {L : Type v} {n : ℕ}
    (f : K → L) (x : D5Leaf K n) :
    d5LeafDegree (mapCoefficients f x) = d5LeafDegree x := by
  cases x <;> rfl

@[simp] theorem mapCoefficients_id {K : Type u} {n : ℕ} (x : D5Leaf K n) :
    mapCoefficients id x = x := by cases x <;> rfl

@[simp] theorem mapCoefficients_comp {K : Type u} {L : Type v} {M : Type w}
    {n : ℕ} (f : K → L) (g : L → M) (x : D5Leaf K n) :
    mapCoefficients g (mapCoefficients f x) = mapCoefficients (g ∘ f) x := by
  cases x <;> rfl

end D5Leaf

/-- Pure coefficient relabeling; no algebraic properties are needed for syntactic homogeneity. -/
def Depth5Circuit.mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) : Depth5Circuit L n where
  leafCount := c.leafCount
  leaves := fun i => D5Leaf.mapCoefficients f (c.leaves i)
  bottomCount := c.bottomCount
  bottomInputs := fun i => (c.bottomInputs i).map (fun e => (f e.1, e.2))
  bottomDegree := c.bottomDegree
  bottomHomogeneous := by
    intro i entry h
    obtain ⟨e, he, rfl⟩ := List.mem_map.mp h
    simpa using c.bottomHomogeneous i e he
  bottomEmpty := by
    intro i h
    exact c.bottomEmpty i (List.map_eq_nil_iff.mp h)
  lowerCount := c.lowerCount
  lowerInputs := c.lowerInputs
  middleCount := c.middleCount
  middleInputs := fun i => (c.middleInputs i).map (fun e => (f e.1, e.2))
  middleDegree := c.middleDegree
  middleHomogeneous := by
    intro i entry h
    obtain ⟨e, he, rfl⟩ := List.mem_map.mp h
    exact c.middleHomogeneous i e he
  middleEmpty := by
    intro i h
    exact c.middleEmpty i (List.map_eq_nil_iff.mp h)
  upperCount := c.upperCount
  upperInputs := c.upperInputs
  outputInputs := c.outputInputs.map (fun e => (f e.1, e.2))
  outputDegree := c.outputDegree
  outputHomogeneous := by
    intro entry h
    obtain ⟨e, he, rfl⟩ := List.mem_map.mp h
    exact c.outputHomogeneous e he
  outputEmpty := by
    intro h
    exact c.outputEmpty (List.map_eq_nil_iff.mp h)

@[simp] theorem Depth5Circuit.lowerInputs_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) (i : Fin c.lowerCount) :
    (c.mapCoefficients f).lowerInputs i = c.lowerInputs i := rfl

@[simp] theorem Depth5Circuit.middleInputs_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) (i : Fin c.middleCount) :
    (c.mapCoefficients f).middleInputs i =
      (c.middleInputs i).map (fun e => (f e.1, e.2)) := rfl

@[simp] theorem Depth5Circuit.upperInputs_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) (i : Fin c.upperCount) :
    (c.mapCoefficients f).upperInputs i = c.upperInputs i := rfl

@[simp] theorem Depth5Circuit.outputInputs_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) :
    (c.mapCoefficients f).outputInputs =
      c.outputInputs.map (fun e => (f e.1, e.2)) := rfl

@[simp] theorem circuitSize_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K → L) (c : Depth5Circuit K n) :
    circuitSize (c.mapCoefficients f) = circuitSize c := rfl

@[simp] theorem d5LeafValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (x : D5Leaf K n) :
    d5LeafValue (x.mapCoefficients f) = MvPolynomial.map f (d5LeafValue x) := by
  cases x <;> simp [D5Leaf.mapCoefficients, d5LeafValue]

@[simp] theorem bottomValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (c : Depth5Circuit K n) (i : Fin c.bottomCount) :
    bottomValue (c.mapCoefficients f) i = MvPolynomial.map f (bottomValue c i) := by
  simp [bottomValue, Depth5Circuit.mapCoefficients, List.map_map,
    Function.comp_def, map_list_sum]

@[simp] theorem lowerValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (c : Depth5Circuit K n) (i : Fin c.lowerCount) :
    lowerValue (c.mapCoefficients f) i = MvPolynomial.map f (lowerValue c i) := by
  simp [lowerValue, bottomValue, Depth5Circuit.mapCoefficients, List.map_map,
    Function.comp_def, map_list_sum, map_list_prod]

@[simp] theorem middleValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (c : Depth5Circuit K n) (i : Fin c.middleCount) :
    middleValue (c.mapCoefficients f) i = MvPolynomial.map f (middleValue c i) := by
  simp [middleValue, lowerValue, bottomValue, Depth5Circuit.mapCoefficients, List.map_map,
    Function.comp_def, map_list_sum, map_list_prod]

@[simp] theorem upperValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (c : Depth5Circuit K n) (i : Fin c.upperCount) :
    upperValue (c.mapCoefficients f) i = MvPolynomial.map f (upperValue c i) := by
  simp [upperValue, middleValue, lowerValue, bottomValue, Depth5Circuit.mapCoefficients, List.map_map,
    Function.comp_def, map_list_sum, map_list_prod]

@[simp] theorem circuitValue_mapCoefficients {K : Type u} {L : Type v}
    [CommSemiring K] [CommSemiring L] {n : ℕ}
    (f : K →+* L) (c : Depth5Circuit K n) :
    circuitValue (c.mapCoefficients f) = MvPolynomial.map f (circuitValue c) := by
  simp [circuitValue, upperValue, middleValue, lowerValue, bottomValue, Depth5Circuit.mapCoefficients, List.map_map,
    Function.comp_def, map_list_sum, map_list_prod]
@[simp] theorem Depth5Circuit.mapCoefficients_id {K : Type u}
    [CommSemiring K] {n : ℕ} (c : Depth5Circuit K n) :
    c.mapCoefficients id = c := by
  cases c
  simp [Depth5Circuit.mapCoefficients]

@[simp] theorem Depth5Circuit.mapCoefficients_comp {K : Type u} {L : Type v}
    {M : Type w} [CommSemiring K] [CommSemiring L] [CommSemiring M]
    {n : ℕ} (f : K → L) (g : L → M) (c : Depth5Circuit K n) :
    (c.mapCoefficients f).mapCoefficients g = c.mapCoefficients (g ∘ f) := by
  cases c
  simp [Depth5Circuit.mapCoefficients, List.map_map, Function.comp_def]

end Problem335

end

end OAI