import Mathlib
import OAI.Combinatorics.Chromatic.Shuffle.QuotientAlg

namespace OAI

section
namespace ElementaryPositivity.RawShuffle
open MvPolynomial
open ElementaryPositivity.ShufflePolynomiality ElementaryPositivity.SeparatedSymmetry
open ElementaryPositivity.CommonTranslation
open scoped TensorProduct
variable {I : Type*} [Fintype I] [DecidableEq I]

noncomputable def crossDifference (d e : I → ℕ) :
    MvPolynomial ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i))) ℚ :=
  ∏ i, ∏ x : Fin (d i), ∏ y : Fin (e i),
    (X (Sum.inl ⟨i,x⟩) - X (Sum.inr ⟨i,y⟩))

lemma prod_sub_perm {α β R : Type*} [Fintype α] [Fintype β] [CommRing R]
    (σ : Equiv.Perm α) (τ : Equiv.Perm β) (l : α → R) (r : β → R) :
    (∏ x : α, (∏ y : β, (l (σ x) - r (τ y)))) = ∏ x : α, (∏ y : β, (l x - r y)) := by
  calc
    _ = ∏ x : α, (∏ y : β, (l (σ x) - r y)) := by
      apply Finset.prod_congr rfl
      intro x hx
      exact Equiv.prod_comp τ (fun y => l (σ x) - r y)
    _ = _ := Equiv.prod_comp σ (fun x => ∏ y : β, (l x - r y))

omit [DecidableEq I] in
lemma rename_crossDifference (d e : I → ℕ)
    (h : ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i))) → ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i)))) :
    rename h (crossDifference d e) =
      ∏ i,∏ x : Fin (d i),∏ y : Fin (e i), (X (h (Sum.inl ⟨i,x⟩))-X (h (Sum.inr ⟨i,y⟩))) := by
  simp only [crossDifference,map_prod,map_sub,rename_X]

omit [DecidableEq I] in
lemma crossDifference_symmetric (d e : I → ℕ) (σ : (∀ i,Equiv.Perm (Fin (d i))) ×
    (∀ i,Equiv.Perm (Fin (e i)))) :
    rename (sumAction (packAction (fun i=>Fin (d i))) (packAction (fun i=>Fin (e i))) σ)
      (crossDifference d e) = crossDifference d e := by
  refine (rename_crossDifference d e _).trans ?_
  exact Finset.prod_congr rfl (fun i hi =>
    prod_sub_perm (R := MvPolynomial ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i))) ℚ)
      (σ.1 i) (σ.2 i) (fun x => X (Sum.inl ⟨i,x⟩)) (fun y => X (Sum.inr ⟨i,y⟩)))

noncomputable def crossTensor (d e : I → ℕ) : S d ⊗[ℚ] S e :=
  separateTensor d e (crossDifference d e)

@[simp] lemma tensorValue_crossTensor (d e : I → ℕ) :
    tensorValue d e (crossTensor d e) = crossDifference d e :=
  tensorValue_separateTensor d e _ (crossDifference_symmetric d e)

noncomputable def relativeRaw (d e : I → ℕ) :
    MvPolynomial ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i))) ℚ →ₐ[ℚ]
      Polynomial (MvPolynomial ((Σi,Fin (d i)) ⊕ (Σi,Fin (e i))) ℚ) :=
  aeval (Sum.elim (fun x => Polynomial.C (X (Sum.inl x)) + Polynomial.X)
    (fun y => Polynomial.C (X (Sum.inr y))))

omit [Fintype I] [DecidableEq I] in
lemma relativeRaw_left (d e : I → ℕ) (f : MvPolynomial (Σi,Fin (d i)) ℚ) :
    relativeRaw d e (rename Sum.inl f) =
      Polynomial.map (rename (R:=ℚ) Sum.inl).toRingHom (taylor f) := by
  induction f using MvPolynomial.induction_on with
  | C r => simp [relativeRaw]
  | add f g hf hg => simp only [map_add,Polynomial.map_add,hf,hg]
  | mul_X f i hf =>
    simp only [map_mul,rename_X,taylor_X,Polynomial.map_mul,hf]
    congr 1
    simp [relativeRaw]

omit [Fintype I] [DecidableEq I] in
lemma relativeRaw_right (d e : I → ℕ) (f : MvPolynomial (Σi,Fin (e i)) ℚ) :
    relativeRaw d e (rename Sum.inr f) = Polynomial.C (rename Sum.inr f) := by
  induction f using MvPolynomial.induction_on with
  | C r => simp [relativeRaw]
  | add f g hf hg => simp only [map_add,hf,hg]
  | mul_X f i hf =>
    simp only [map_mul,rename_X,hf]
    congr 1
    simp [relativeRaw]

omit [Fintype I] [DecidableEq I] in
lemma map_taylorS_left (d e : I → ℕ) (f : S d) :
    Polynomial.map (tensorValueAlg d e).toRingHom
      (Polynomial.map (Algebra.TensorProduct.includeLeft : S d →ₐ[ℚ] S d ⊗[ℚ] S e).toRingHom
        (taylorS d f)) =
      Polynomial.map (rename (R:=ℚ) Sum.inl).toRingHom (taylor f.val) := by
  rw [← map_taylorS d f,Polynomial.map_map,Polynomial.map_map]
  congr 1
  apply RingHom.ext
  intro g
  change tensorValue d e (g ⊗ₜ[ℚ] 1) = rename Sum.inl g.val
  simp

omit [Fintype I] [DecidableEq I] in
lemma map_relativeTaylor (d e : I → ℕ) (f : S d ⊗[ℚ] S e) :
    Polynomial.map (tensorValueAlg d e).toRingHom (relativeTaylor d e f) =
      relativeRaw d e (tensorValue d e f) := by
  induction f using TensorProduct.inductionOn with
  | tmul f g =>
    rw [relativeTaylor_tmul,Polynomial.map_mul,map_taylorS_left,
      Polynomial.map_C,tensorValue_tmul,map_mul,relativeRaw_left,relativeRaw_right]
    congr 1
    change Polynomial.C (tensorValue d e (1 ⊗ₜ[ℚ] g)) = _
    simp
  | add f g hf hg => simp only [map_add,Polynomial.map_add,hf,hg]

omit [DecidableEq I] in
lemma relativeRaw_crossDifference (d e : I → ℕ) :
    relativeRaw d e (crossDifference d e) =
      ∏ i, ∏ x : Fin (d i), ∏ y : Fin (e i),
        (Polynomial.X + Polynomial.C (X (Sum.inl ⟨i,x⟩) - X (Sum.inr ⟨i,y⟩))) := by
  simp only [crossDifference,map_prod,map_sub]
  apply Finset.prod_congr rfl
  intro i hi
  apply Finset.prod_congr rfl
  intro x hx
  apply Finset.prod_congr rfl
  intro y hy
  simp [relativeRaw]
  ring

omit [DecidableEq I] in
lemma relativeRaw_crossDifference_monic (d e : I → ℕ) :
    (relativeRaw d e (crossDifference d e)).Monic := by
  rw [relativeRaw_crossDifference]
  apply Polynomial.monic_prod_of_monic
  intro i hi
  apply Polynomial.monic_prod_of_monic
  intro x hx
  apply Polynomial.monic_prod_of_monic
  intro y hy
  exact Polynomial.monic_X_add_C _

lemma relativeTaylor_crossTensor_monic (d e : I → ℕ) :
    (relativeTaylor d e (crossTensor d e)).Monic := by
  apply Polynomial.monic_of_injective (f := (tensorValueAlg d e).toRingHom) (tensorValue_injective d e)
  rw [map_relativeTaylor,tensorValue_crossTensor]
  exact relativeRaw_crossDifference_monic d e

noncomputable def crossClearing (a : I → I → ℕ) (μ : (I → ℕ) → ℝ) (d e : I → ℕ) :
    Polynomial (B a μ d ⊗[ℚ] B a μ e) :=
  Polynomial.map (quotientTensor a μ d e).toRingHom (relativeTaylor d e (crossTensor d e))

lemma crossClearing_monic (a : I → I → ℕ) (μ : (I → ℕ) → ℝ) (d e : I → ℕ) :
    (crossClearing a μ d e).Monic :=
  (relativeTaylor_crossTensor_monic d e).map _

lemma crossClearing_cancel (a : I → I → ℕ) (μ : (I → ℕ) → ℝ) (d e : I → ℕ)
    (f : Polynomial (B a μ d ⊗[ℚ] B a μ e)) :
    crossClearing a μ d e * f = 0 ↔ f = 0 :=
  (crossClearing_monic a μ d e).mul_right_eq_zero_iff

end ElementaryPositivity.RawShuffle

end

end OAI