import Mathlib
import OAI.Combinatorics.Chromatic.Shuffle.RestrictionB

namespace OAI

section
namespace ElementaryPositivity.RawShuffle.SplitTree
open MvPolynomial
open scoped TensorProduct

noncomputable def extendPolynomial {A B α β : Type*} [CommRing A] [CommRing B]
    [Algebra ℚ A] [Algebra ℚ B] (f : A →ₐ[ℚ] B) (j : α → β) :
    MvPolynomial α A →ₐ[ℚ] MvPolynomial β B :=
  ((rename j).restrictScalars ℚ).comp (mapAlgHom f)

@[simp] lemma extendPolynomial_C {A B α β : Type*} [CommRing A] [CommRing B]
    [Algebra ℚ A] [Algebra ℚ B] (f : A →ₐ[ℚ] B) (j : α → β) (a : A) :
    extendPolynomial f j (C a) = C (f a) := by
  simp [extendPolynomial]

@[simp] lemma extendPolynomial_X {A B α β : Type*} [CommRing A] [CommRing B]
    [Algebra ℚ A] [Algebra ℚ B] (f : A →ₐ[ℚ] B) (j : α → β) (i : α) :
    extendPolynomial f j (X i) = X (j i) := by
  simp [extendPolynomial]

lemma extendPolynomial_map {A B C α β : Type*} [CommRing A] [CommRing B] [CommRing C]
    [Algebra ℚ A] [Algebra ℚ B] [Algebra ℚ C]
    (f : A →ₐ[ℚ] B) (g : B →ₐ[ℚ] C) (j : α → β) (p : MvPolynomial α A) :
    map g.toRingHom (extendPolynomial f j p) = extendPolynomial (g.comp f) j p := by
  simp only [extendPolynomial,AlgHom.comp_apply,AlgHom.restrictScalars_apply,
    mapAlgHom_apply,map_rename,map_map,AlgHom.toRingHom_eq_coe]
  rfl

lemma extendPolynomial_preMap {A B C α β : Type*} [CommRing A] [CommRing B] [CommRing C]
    [Algebra ℚ A] [Algebra ℚ B] [Algebra ℚ C]
    (f : A →ₐ[ℚ] B) (g : B →ₐ[ℚ] C) (j : α → β) (p : MvPolynomial α A) :
    extendPolynomial g j (map f.toRingHom p) = extendPolynomial (g.comp f) j p := by
  simp only [extendPolynomial,AlgHom.comp_apply,AlgHom.restrictScalars_apply,
    mapAlgHom_apply,map_map,AlgHom.toRingHom_eq_coe]
  rfl

lemma toMvPolynomial_map {A B α : Type*} [CommRing A] [CommRing B]
    [Algebra ℚ A] [Algebra ℚ B] (f : A →ₐ[ℚ] B) (i : α) (p : Polynomial A) :
    map f.toRingHom (Polynomial.toMvPolynomial i p) =
      Polynomial.toMvPolynomial i (Polynomial.map f.toRingHom p) := by
  induction p using Polynomial.induction_on' with
  | add p q hp hq => simp only [map_add,Polynomial.map_add,hp,hq]
  | monomial n a => simp [← Polynomial.C_mul_X_pow_eq_monomial]

end ElementaryPositivity.RawShuffle.SplitTree

namespace ElementaryPositivity.RawShuffle.SplitTree
open MvPolynomial
open scoped TensorProduct
universe u
variable {I : Type u} [Fintype I] [DecidableEq I]

@[reducible] def Centers : SplitTree I → Type
  | .leaf _ => Unit
  | .node l r => l.Centers ⊕ r.Centers

noncomputable def centerTranslation (A : (I → ℕ) → CommAlgCat.{u} ℚ)
    (τ : ∀ d, A d →ₐ[ℚ] Polynomial (A d)) :
    (T : SplitTree I) → tensor A T →ₐ[ℚ] MvPolynomial T.Centers (tensor A T)
  | .leaf d => ((Polynomial.toMvPolynomial ()).restrictScalars ℚ).comp (τ d)
  | .node l r =>
    let L := (extendPolynomial (Algebra.TensorProduct.includeLeft :
      tensor A l →ₐ[ℚ] tensor A l ⊗[ℚ] tensor A r) Sum.inl).comp (centerTranslation A τ l)
    let R := (extendPolynomial (Algebra.TensorProduct.includeRight :
      tensor A r →ₐ[ℚ] tensor A l ⊗[ℚ] tensor A r) Sum.inr).comp (centerTranslation A τ r)
    Algebra.TensorProduct.lift (S:=ℚ) L R (fun x y => mul_comm (L x) (R y))

omit [Fintype I] [DecidableEq I] in
@[simp] lemma centerTranslation_tmul (A : (I → ℕ) → CommAlgCat.{u} ℚ)
    (τ : ∀ d, A d →ₐ[ℚ] Polynomial (A d)) (l r : SplitTree I)
    (x : tensor A l) (y : tensor A r) :
    centerTranslation A τ (.node l r) (x ⊗ₜ[ℚ] y) =
      extendPolynomial (Algebra.TensorProduct.includeLeft :
        tensor A l →ₐ[ℚ] tensor A l ⊗[ℚ] tensor A r) Sum.inl (centerTranslation A τ l x) *
      extendPolynomial (Algebra.TensorProduct.includeRight :
        tensor A r →ₐ[ℚ] tensor A l ⊗[ℚ] tensor A r) Sum.inr (centerTranslation A τ r y) := by
  rfl

omit [Fintype I] [DecidableEq I] in
lemma centerTranslation_natural (A C : (I → ℕ) → CommAlgCat.{u} ℚ)
    (f : ∀ d, A d →ₐ[ℚ] C d)
    (τ : ∀ d, A d →ₐ[ℚ] Polynomial (A d)) (υ : ∀ d, C d →ₐ[ℚ] Polynomial (C d))
    (h : ∀ d x, Polynomial.map (f d).toRingHom (τ d x) = υ d (f d x))
    (T : SplitTree I) (x : tensor A T) :
    map (tensorMap A C f T).toRingHom (centerTranslation A τ T x) =
      centerTranslation C υ T (tensorMap A C f T x) := by
  induction T with
  | leaf d =>
    change map (f d).toRingHom (Polynomial.toMvPolynomial () (τ d x)) =
      Polynomial.toMvPolynomial () (υ d (f d x))
    rw [toMvPolynomial_map,h]
  | node l r ihl ihr =>
    induction x using TensorProduct.inductionOn with
    | tmul x y =>
      change map (Algebra.TensorProduct.map (tensorMap A C f l) (tensorMap A C f r)).toRingHom
        (centerTranslation A τ (.node l r) (x ⊗ₜ[ℚ] y)) =
        centerTranslation C υ (.node l r) (tensorMap A C f l x ⊗ₜ[ℚ] tensorMap A C f r y)
      erw [centerTranslation_tmul,centerTranslation_tmul,map_mul]
      rw [extendPolynomial_map,extendPolynomial_map,← ihl x,← ihr y,
        extendPolynomial_preMap,extendPolynomial_preMap]
      rw [Algebra.TensorProduct.map_comp_includeLeft, Algebra.TensorProduct.map_comp_includeRight]
    | add x y hx hy => simp only [map_add,hx,hy]

noncomputable def rawCenteredRestriction (T : SplitTree I) :
    S T.dim →ₐ[ℚ] MvPolynomial T.Centers (tensor rawFamily T) :=
  (centerTranslation rawFamily taylorS T).comp (rawRestriction T)

noncomputable def centeredRestrictionB (a : I → I → ℕ) (c η : I → ℝ) (hc : ∀ i,0<c i)
    (θ : ℝ) (T : SplitTree I) (h : T.OnSlope c η θ) :
    B a (SlopeArithmetic.slope c η) T.dim →ₐ[ℚ]
      MvPolynomial T.Centers (tensor (quotientFamily a (SlopeArithmetic.slope c η)) T) :=
  (centerTranslation (quotientFamily a (SlopeArithmetic.slope c η))
    (taylorB a (SlopeArithmetic.slope c η)) T).comp (restrictionB a c η hc θ T h)

theorem centeredRestrictionB_mk (a : I → I → ℕ) (c η : I → ℝ) (hc : ∀ i,0<c i)
    (θ : ℝ) (T : SplitTree I) (h : T.OnSlope c η θ) (f : S T.dim) :
    centeredRestrictionB a c η hc θ T h (quotientAlg a (SlopeArithmetic.slope c η) T.dim f) =
      map (quotientMap a (SlopeArithmetic.slope c η) T).toRingHom (rawCenteredRestriction T f) := by
  simp only [centeredRestrictionB,rawCenteredRestriction,AlgHom.comp_apply,restrictionB_mk]
  symm
  apply centerTranslation_natural
  intro d x
  exact (taylorB_mk a (SlopeArithmetic.slope c η) d x).symm

end ElementaryPositivity.RawShuffle.SplitTree

end

end OAI