import Mathlib

namespace OAI

section
namespace ElementaryPositivity.ShufflePolynomiality

open MvPolynomial

variable {α : Type*} [DecidableEq α]

noncomputable def diagonal (i j : α) : MvPolynomial α ℚ := X j - X i

def merge (i j x : α) : α := if x = j then i else x

noncomputable def identify (i j : α) : MvPolynomial α ℚ →ₐ[ℚ] MvPolynomial α ℚ :=
  rename (merge i j)

@[simp] lemma merge_left (i j : α) : merge i j i = i := by
  simp [merge]

@[simp] lemma merge_right (i j : α) : merge i j j = i := by
  simp [merge]

@[simp] lemma identify_diagonal (i j : α) : identify i j (diagonal i j) = 0 := by
  simp [identify, diagonal]

lemma diagonal_dvd_sub_identify (i j : α) (f : MvPolynomial α ℚ) :
    diagonal i j ∣ f - identify i j f := by
  induction f using MvPolynomial.induction_on with
  | C r => simp [identify]
  | add p q hp hq =>
    convert dvd_add hp hq using 1
    simp only [map_add]
    ring
  | mul_X p k hp =>
    have hx : diagonal i j ∣ X k - identify i j (X k) := by
      by_cases hk : k = j
      · subst k
        simp [identify, diagonal]
      · simp [identify, merge, hk]
    convert dvd_add (dvd_mul_of_dvd_left hp (X k))
      (dvd_mul_of_dvd_right hx (identify i j p)) using 1
    simp only [map_mul]
    ring

lemma diagonal_dvd_iff_identify_eq_zero (i j : α) (f : MvPolynomial α ℚ) :
    diagonal i j ∣ f ↔ identify i j f = 0 := by
  constructor
  · intro h
    simpa using map_dvd (identify i j) h
  · intro h
    simpa [h] using diagonal_dvd_sub_identify i j f

lemma ker_identify (i j : α) :
    RingHom.ker (identify i j) = Ideal.span {diagonal i j} := by
  ext f
  simp [RingHom.mem_ker, Ideal.mem_span_singleton, diagonal_dvd_iff_identify_eq_zero]

omit [DecidableEq α] in
lemma diagonal_ne_zero {i j : α} (hij : i ≠ j) : diagonal i j ≠ 0 := by
  simpa [diagonal, sub_eq_zero, MvPolynomial.X_inj] using hij.symm

lemma diagonal_prime {i j : α} (hij : i ≠ j) : Prime (diagonal i j) := by
  apply (Ideal.span_singleton_prime (diagonal_ne_zero hij)).mp
  rw [← ker_identify]
  exact RingHom.ker_isPrime _

section Ordered
variable [LinearOrder α]

lemma merge_equal_for_ordered_pair {i j a b : α} (hij : i < j) (hab : a < b)
    (h : merge i j a = merge i j b) : a = i ∧ b = j := by
  by_cases ha : a = j
  · subst a
    by_cases hb : b = j
    · subst b
      exact (lt_irrefl _ hab).elim
    · simp only [merge, ite_eq_right hb] at h
      subst b
      exact (lt_asymm hij hab).elim
  · by_cases hb : b = j
    · subst b
      simpa [merge, ha] using h
    · simp only [merge, ite_eq_right ha, ite_eq_right hb] at h
      exact (hab.ne h).elim

lemma diagonals_not_dvd {i j a b : α} (hij : i < j) (hab : a < b)
    (hne : (i,j) ≠ (a,b)) : ¬ diagonal i j ∣ diagonal a b := by
  intro h
  have hz := (diagonal_dvd_iff_identify_eq_zero i j _).mp h
  have hm : merge i j a = merge i j b := by
    have hrev : merge i j b = merge i j a := by
      simpa [identify, diagonal, sub_eq_zero, MvPolynomial.X_inj] using hz
    exact hrev.symm
  obtain ⟨ha, hb⟩ := merge_equal_for_ordered_pair hij hab hm
  exact hne (by simp [ha, hb])

lemma diagonals_isRelPrime {i j a b : α} (hij : i < j) (hab : a < b)
    (hne : (i,j) ≠ (a,b)) : IsRelPrime (diagonal i j) (diagonal a b) := by
  exact (diagonal_prime hij.ne).irreducible.isRelPrime_iff_not_dvd.mpr
    (diagonals_not_dvd hij hab hne)

theorem diagonal_powers_product_dvd (s : Finset (α × α))
    (hs : ∀ ij ∈ s, ij.1 < ij.2) (e : α × α → ℕ) (f : MvPolynomial α ℚ)
    (hf : ∀ ij ∈ s, diagonal ij.1 ij.2 ^ e ij ∣ f) :
    (∏ ij ∈ s, diagonal ij.1 ij.2 ^ e ij) ∣ f := by
  apply Finset.prod_dvd_of_isRelPrime _ hf
  intro ij hij kl hkl hne
  exact (diagonals_isRelPrime (hs ij hij) (hs kl hkl) hne).pow

end Ordered

lemma merge_swap (i j : α) : merge i j ∘ Equiv.swap i j = merge i j := by
  funext x
  by_cases hi : x = i
  · subst x
    simp
  · by_cases hj : x = j
    · subst x
      simp
    · simp [Equiv.swap_apply_of_ne_of_ne hi hj, Function.comp_apply]

theorem diagonal_dvd_of_antisymmetric (i j : α) (f : MvPolynomial α ℚ)
    (hf : rename (Equiv.swap i j) f = -f) : diagonal i j ∣ f := by
  apply (diagonal_dvd_iff_identify_eq_zero i j f).mpr
  have h := congrArg (identify i j) hf
  simp only [identify, MvPolynomial.rename_rename, merge_swap, map_neg] at h
  have hh : (2 : ℚ) • (rename (merge i j) f) = 0 := by
    rw [two_smul]
    exact add_eq_zero_iff_eq_neg.mpr h
  exact (smul_eq_zero.mp hh).resolve_left (by norm_num)

theorem vandermonde_dvd [LinearOrder α] (s : Finset α) (f : MvPolynomial α ℚ)
    (hf : ∀ i ∈ s, ∀ j ∈ s, i < j → rename (Equiv.swap i j) f = -f) :
    (∏ ij ∈ (s ×ˢ s).filter (fun ij => ij.1 < ij.2), diagonal ij.1 ij.2) ∣ f := by
  let t := (s ×ˢ s).filter (fun ij => ij.1 < ij.2)
  have ht : ∀ ij ∈ t, ij.1 < ij.2 := by
    intro ij hij
    exact (Finset.mem_filter.mp hij).2
  simpa using diagonal_powers_product_dvd t ht (fun _ => 1) f (by
    intro ij hij
    obtain ⟨hij, hlt⟩ := Finset.mem_filter.mp hij
    obtain ⟨hi,hj⟩ := Finset.mem_product.mp hij
    simpa using diagonal_dvd_of_antisymmetric ij.1 ij.2 f (hf ij.1 hi ij.2 hj hlt))

section Alternation
variable {G : Type*} [Group G] [Fintype G]

noncomputable def alternate (ρ : G →* Equiv.Perm α) (χ : G →* ℤˣ)
    (f : MvPolynomial α ℚ) : MvPolynomial α ℚ :=
  ∑ g : G, (χ g : ℤ) • rename (ρ g) f

omit [DecidableEq α] in
lemma rename_alternate_of_sign_neg (ρ : G →* Equiv.Perm α) (χ : G →* ℤˣ)
    (f : MvPolynomial α ℚ) (t : G) (ht : χ t = -1) :
    rename (ρ t) (alternate ρ χ f) = -alternate ρ χ f := by
  rw [alternate, map_sum]
  calc
    (∑ g : G, rename (ρ t) ((χ g : ℤ) • rename (ρ g) f)) =
      -(∑ g : G, (χ (t*g) : ℤ) • rename (ρ (t*g)) f) := by
        rw [← Finset.sum_neg_distrib]
        apply Finset.sum_congr rfl
        intro g _
        simp only [map_zsmul, MvPolynomial.rename_rename, map_mul,
          Equiv.Perm.coe_mul, ht, neg_one_mul, Units.val_neg, neg_smul, neg_neg]
    _ = -alternate ρ χ f := by
      simpa [alternate] using congrArg Neg.neg
        (Equiv.sum_comp (Equiv.mulLeft t) (fun g => (χ g : ℤ) • rename (ρ g) f))

lemma diagonal_dvd_alternate (ρ : G →* Equiv.Perm α) (χ : G →* ℤˣ)
    (f : MvPolynomial α ℚ) (i j : α) (t : G)
    (hρ : ρ t = Equiv.swap i j) (hχ : χ t = -1) :
    diagonal i j ∣ alternate ρ χ f := by
  apply diagonal_dvd_of_antisymmetric
  rw [← hρ]
  exact rename_alternate_of_sign_neg ρ χ f t hχ

theorem same_pack_alternation_polynomial [Fintype α] [LinearOrder α]
    (f : MvPolynomial α ℚ) :
    ∃ q : MvPolynomial α ℚ,
      alternate (MonoidHom.id (Equiv.Perm α)) Equiv.Perm.sign f =
        (∏ ij ∈ (Finset.univ ×ˢ Finset.univ).filter
          (fun ij : α × α => ij.1 < ij.2), diagonal ij.1 ij.2) * q := by
  apply vandermonde_dvd Finset.univ
  intro i _ j _ hij
  apply rename_alternate_of_sign_neg (MonoidHom.id (Equiv.Perm α)) Equiv.Perm.sign
    f (Equiv.swap i j)
  exact Equiv.Perm.sign_swap hij.ne

end Alternation

section UnorderedPairs

lemma merge_equal_pair {i j a b : α} (hab : a ≠ b)
    (h : merge i j a = merge i j b) :
    (a = i ∧ b = j) ∨ (a = j ∧ b = i) := by
  by_cases ha : a = j
  · subst a
    by_cases hb : b = j
    · exact (hab hb.symm).elim
    · simp only [merge, ite_eq_right hb] at h
      exact Or.inr ⟨rfl, h.symm⟩
  · by_cases hb : b = j
    · subst b
      simp only [merge, ite_eq_right ha] at h
      exact Or.inl ⟨h, rfl⟩
    · simp only [merge, ite_eq_right ha, ite_eq_right hb] at h
      exact (hab h).elim

lemma independent_diagonals {i j a b : α} (hij : i ≠ j) (hab : a ≠ b)
    (h₁ : (i,j) ≠ (a,b)) (h₂ : (i,j) ≠ (b,a)) :
    IsRelPrime (diagonal i j) (diagonal a b) := by
  apply (diagonal_prime hij).irreducible.isRelPrime_iff_not_dvd.mpr
  intro hd
  have hz := (diagonal_dvd_iff_identify_eq_zero i j _).mp hd
  have he : merge i j b = merge i j a := by
    simpa [identify, diagonal, sub_eq_zero, MvPolynomial.X_inj] using hz
  obtain (⟨ha,hb⟩ | ⟨ha,hb⟩) := merge_equal_pair hab he.symm
  · exact h₁ (by simp [ha, hb])
  · exact h₂ (by simp [ha, hb])

theorem pair_powers_product_dvd (s : Finset (α × α))
    (hs : ∀ ij ∈ s, ij.1 ≠ ij.2)
    (hrev : ∀ ij ∈ s, (ij.2,ij.1) ∉ s)
    (e : α × α → ℕ) (f : MvPolynomial α ℚ)
    (hf : ∀ ij ∈ s, diagonal ij.1 ij.2 ^ e ij ∣ f) :
    (∏ ij ∈ s, diagonal ij.1 ij.2 ^ e ij) ∣ f := by
  apply Finset.prod_dvd_of_isRelPrime _ hf
  intro ij hij kl hkl hne
  apply (independent_diagonals (hs ij hij) (hs kl hkl) hne _).pow
  intro hr
  apply hrev ij hij
  have heq : (ij.2,ij.1) = kl := by
    simpa only [Prod.swap, Prod.eta] using congrArg Prod.swap hr
  rwa [heq]

end UnorderedPairs

section Packs

variable {I : Type*} [Fintype I] [DecidableEq I]
variable (V : I → Type*) [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]

def packAction : (∀ i, Equiv.Perm (V i)) →* Equiv.Perm (Σ i, V i) where
  toFun g := Equiv.sigmaCongrRight g
  map_one' := by apply Equiv.ext; rintro ⟨i,a⟩; rfl
  map_mul' g h := by apply Equiv.ext; rintro ⟨i,a⟩; rfl

def packSign (E : I → Prop) [DecidablePred E] :
    (∀ i, Equiv.Perm (V i)) →* ℤˣ where
  toFun g := ∏ i, if E i then Equiv.Perm.sign (g i) else 1
  map_one' := by simp
  map_mul' g h := by
    simp only [Pi.mul_apply, map_mul]
    rw [← Finset.prod_mul_distrib]
    apply Finset.prod_congr rfl
    intro i _
    split_ifs <;> simp

omit [Fintype I] [∀ i, Fintype (V i)] in
lemma packAction_transposition (i : I) (a b : V i) :
    packAction V (Function.update 1 i (Equiv.swap a b)) =
      Equiv.swap (⟨i,a⟩ : Σ i,V i) ⟨i,b⟩ := by
  apply Equiv.ext
  rintro ⟨j,c⟩
  by_cases hj : j = i
  · subst j
    change (⟨i, (Function.update (1 : ∀ i, Equiv.Perm (V i)) i (Equiv.swap a b)) i c⟩ : Σ i,V i) = _
    rw [Function.update_self]
    simp only [Equiv.swap_apply_def, Sigma.mk.inj_iff, heq_eq_eq, true_and]
    split_ifs <;> rfl
  · change (⟨j, (Function.update (1 : ∀ i, Equiv.Perm (V i)) i (Equiv.swap a b)) j c⟩ : Σ i,V i) = _
    rw [Function.update_of_ne hj]
    exact (Equiv.swap_apply_of_ne_of_ne
      (fun h => hj (congrArg Sigma.fst h))
      (fun h => hj (congrArg Sigma.fst h))).symm

lemma packSign_transposition (E : I → Prop) [DecidablePred E]
    (i : I) (a b : V i) (hi : E i) (hab : a ≠ b) :
    packSign V E (Function.update 1 i (Equiv.swap a b)) = -1 := by
  change (∏ j, if E j then
    Equiv.Perm.sign ((Function.update (1 : ∀ i, Equiv.Perm (V i)) i
      (Equiv.swap a b)) j) else 1) = -1
  rw [Fintype.prod_eq_single i]
  · simp [hi, Equiv.Perm.sign_swap hab]
  · intro j hji
    simp [Function.update_of_ne hji]

lemma pack_alternate_diagonal (E : I → Prop) [DecidablePred E]
    (f : MvPolynomial (Σ i,V i) ℚ) (i : I) (a b : V i)
    (hi : E i) (hab : a ≠ b) :
    diagonal ⟨i,a⟩ ⟨i,b⟩ ∣ alternate (packAction V) (packSign V E) f := by
  apply diagonal_dvd_alternate (packAction V) (packSign V E) f
    ⟨i,a⟩ ⟨i,b⟩ (Function.update 1 i (Equiv.swap a b))
  · exact packAction_transposition V i a b
  · exact packSign_transposition V E i a b hi hab

noncomputable def packPairs (E : I → Prop) [DecidablePred E] :
    Finset ((Σ i,V i) × (Σ i,V i)) := by
  classical
  exact (Finset.univ ×ˢ Finset.univ).filter (fun ij =>
    ij.1.1 = ij.2.1 ∧ E ij.1.1 ∧
      Fintype.equivFin (Σ i,V i) ij.1 < Fintype.equivFin (Σ i,V i) ij.2)

noncomputable def packVandermonde (E : I → Prop) [DecidablePred E] :
    MvPolynomial (Σ i,V i) ℚ :=
  ∏ ij ∈ packPairs V E, diagonal ij.1 ij.2

theorem pack_alternation_polynomial (E : I → Prop) [DecidablePred E]
    (f : MvPolynomial (Σ i,V i) ℚ) :
    ∃ q : MvPolynomial (Σ i,V i) ℚ,
      alternate (packAction V) (packSign V E) f = packVandermonde V E * q := by
  classical
  change packVandermonde V E ∣ alternate (packAction V) (packSign V E) f
  unfold packVandermonde
  have hi (ij) (hij : ij ∈ packPairs V E) :
      ij.1.1 = ij.2.1 ∧ E ij.1.1 ∧
      Fintype.equivFin (Σ i,V i) ij.1 < Fintype.equivFin (Σ i,V i) ij.2 :=
    (Finset.mem_filter.mp hij).2
  have hn (ij) (hij : ij ∈ packPairs V E) : ij.1 ≠ ij.2 := by
    intro h
    exact (hi ij hij).2.2.ne (congrArg (Fintype.equivFin (Σ i,V i)) h)
  have hr (ij) (hij : ij ∈ packPairs V E) : (ij.2,ij.1) ∉ packPairs V E := by
    intro hrev
    exact lt_asymm (hi ij hij).2.2 (hi _ hrev).2.2
  simpa using pair_powers_product_dvd (packPairs V E) hn hr (fun _ => 1)
    (alternate (packAction V) (packSign V E) f) (by
      rintro ⟨⟨i,a⟩,⟨j,b⟩⟩ hij
      have he : i = j := (hi _ hij).1
      subst j
      have hab : a ≠ b := by
        intro h
        exact hn _ hij (by cases h; rfl)
      simpa using pack_alternate_diagonal V E f i a b (hi _ hij).2.1 hab)

end Packs

section FinPacks
variable {I : Type*} [Fintype I] [DecidableEq I]
variable (n : I → ℕ) (E : I → Prop) [DecidablePred E]

noncomputable def naturalVandermonde : MvPolynomial (Σ i, Fin (n i)) ℚ :=
  ∏ i, if E i then (Matrix.vandermonde (fun a : Fin (n i) =>
    (X ⟨i,a⟩ : MvPolynomial (Σ i, Fin (n i)) ℚ))).det else 1

def finPackPair (a : Σ i, Fin (n i) × Fin (n i)) :
    (Σ i, Fin (n i)) × (Σ i, Fin (n i)) :=
  (⟨a.1,a.2.1⟩, ⟨a.1,a.2.2⟩)

omit [Fintype I] [DecidableEq I] in
lemma finPackPair_injective : Function.Injective (finPackPair n) := by
  rintro ⟨i,a,b⟩ ⟨j,c,d⟩ h
  have hij : i = j := congrArg (fun p => p.1.1) h
  subst j
  simp only [finPackPair, Prod.mk.injEq, Sigma.mk.inj_iff, heq_eq_eq, true_and] at h
  obtain ⟨rfl,rfl⟩ := h
  rfl

noncomputable def naturalPairs : Finset (Σ i, Fin (n i) × Fin (n i)) :=
  Finset.univ.sigma (fun i => (Finset.univ ×ˢ Finset.univ).filter
    (fun ab : Fin (n i) × Fin (n i) => E i ∧ ab.1 < ab.2))

omit [DecidableEq I] in
lemma naturalVandermonde_product : naturalVandermonde n E =
    ∏ a ∈ naturalPairs n E, diagonal (finPackPair n a).1 (finPackPair n a).2 := by
  rw [naturalVandermonde, naturalPairs, Finset.prod_sigma]
  apply Finset.prod_congr rfl
  intro i _
  by_cases hi : E i
  · simp only [hi, ite_true, Matrix.det_vandermonde, true_and]
    rw [Finset.prod_filter, Finset.prod_product]
    apply Finset.prod_congr rfl
    intro a _
    simp only [← Finset.filter_lt_eq_Ioi, Finset.prod_filter, diagonal, finPackPair]
  · simp [hi]

omit [DecidableEq I] in
lemma rename_naturalVandermonde (g : ∀ i, Equiv.Perm (Fin (n i))) :
    rename (packAction (fun i => Fin (n i)) g) (naturalVandermonde n E) =
      (packSign (fun i => Fin (n i)) E g : ℤ) • naturalVandermonde n E := by
  rw [naturalVandermonde, map_prod]
  simp only [packSign, MonoidHom.coe_mk, OneHom.coe_mk, Units.coe_prod,
    zsmul_eq_mul, Int.cast_prod]
  rw [← Finset.prod_mul_distrib]
  apply Finset.prod_congr rfl
  intro i _
  by_cases hi : E i
  · simp only [hi, ite_true]
    change ((rename (packAction (fun i => Fin (n i)) g)).toRingHom)
      (Matrix.vandermonde (fun a : Fin (n i) => X ⟨i,a⟩)).det = _
    rw [RingHom.map_det]
    have hm : (rename (packAction (fun i => Fin (n i)) g)).toRingHom.mapMatrix
        (Matrix.vandermonde (fun a : Fin (n i) =>
          (X ⟨i,a⟩ : MvPolynomial (Σ i, Fin (n i)) ℚ))) =
        (Matrix.vandermonde (fun a : Fin (n i) =>
          (X ⟨i,a⟩ : MvPolynomial (Σ i, Fin (n i)) ℚ))).submatrix (g i) id := by
      ext a b
      simp [Matrix.vandermonde, Matrix.submatrix_apply, packAction]
    rw [hm, Matrix.det_permute]
  · simp [hi]

lemma naturalVandermonde_dvd_alternate (f : MvPolynomial (Σ i, Fin (n i)) ℚ) :
    naturalVandermonde n E ∣
      alternate (packAction (fun i => Fin (n i))) (packSign (fun i => Fin (n i)) E) f := by
  rw [naturalVandermonde_product]
  apply Finset.prod_dvd_of_isRelPrime
  · rintro ⟨i,a,b⟩ hi ⟨j,c,d⟩ hj hne
    change (⟨i,(a,b)⟩ : Σ i, Fin (n i) × Fin (n i)) ∈ naturalPairs n E at hi
    change (⟨j,(c,d)⟩ : Σ i, Fin (n i) × Fin (n i)) ∈ naturalPairs n E at hj
    simp only [naturalPairs, Finset.mem_sigma, Finset.mem_univ, Finset.mem_filter,
      Finset.mem_product, true_and] at hi hj
    have hab : (⟨i,a⟩ : Σ i,Fin (n i)) ≠ ⟨i,b⟩ := by simpa using hi.2.ne
    have hcd : (⟨j,c⟩ : Σ i,Fin (n i)) ≠ ⟨j,d⟩ := by simpa using hj.2.ne
    apply independent_diagonals hab hcd
    · exact fun h => hne (finPackPair_injective n h)
    · intro hr
      have hij : i = j := congrArg (fun p => p.1.1) hr
      subst j
      simp only [Prod.mk.injEq, Sigma.mk.inj_iff, heq_eq_eq, true_and] at hr
      obtain ⟨rfl,rfl⟩ := hr
      exact lt_asymm hi.2 hj.2
  · rintro ⟨i,a,b⟩ ha
    simp only [naturalPairs, Finset.mem_sigma, Finset.mem_univ, Finset.mem_filter,
      Finset.mem_product, true_and] at ha
    exact pack_alternate_diagonal (fun i => Fin (n i)) E f i a b ha.1 ha.2.ne

end FinPacks

section FractionRename
variable {α : Type*} [DecidableEq α]

end FractionRename
end ElementaryPositivity.ShufflePolynomiality
end

end OAI