import Mathlib
import Development.AbelianVarietyTheory.Definitions.Divisors.EqZeroOfForallPowDvd

set_option autoImplicit false

noncomputable section

open MvPowerSeries GlobalTheory GlobalTheory.Katz GlobalTheory.QLog

namespace GlobalTheory.BinomRight

theorem prod_monomial' {R σ ι : Type} [CommRing R] (s : Finset ι) (n : ι → σ →₀ ℕ) (c : ι → R) :
    ∏ i ∈ s, (monomial (n i) (c i) : MvPowerSeries σ R) =
      monomial (∑ i ∈ s, n i) (∏ i ∈ s, c i) := by
  classical
  induction s using Finset.induction_on with
  | empty => simp [monomial_zero_eq_C]
  | insert j s hj ih =>
    rw [Finset.prod_insert hj, ih, monomial_mul_monomial, Finset.sum_insert hj, Finset.prod_insert hj]

theorem add_pow_X' {R σ : Type} [CommRing R] (u v : σ) (k : ℕ) :
    ((X u + X v : MvPowerSeries σ R)) ^ k =
      ∑ j ∈ Finset.range (k + 1),
        monomial (Finsupp.single u j + Finsupp.single v (k - j)) (k.choose j : R) := by
  rw [add_pow]
  refine Finset.sum_congr rfl fun j _ => ?_
  rw [X_pow_eq, X_pow_eq, monomial_mul_monomial, ← map_natCast (C (σ := σ) (R := R)),
    ← monomial_zero_eq_C, monomial_mul_monomial, add_zero]
  simp only [one_mul]

end GlobalTheory.BinomRight

namespace GlobalTheory.BinomRight

variable {R : Type} [CommRing R] {d : ℕ}

def expo (α : Fin d ⊕ Fin d →₀ ℕ) (J : Fin d → ℕ) : Fin d ⊕ (Fin d ⊕ Fin d) →₀ ℕ :=
  (∑ i, Finsupp.single (Sum.inl i) (α (Sum.inl i))) +
    ∑ i, (Finsupp.single (Sum.inr (Sum.inl i)) (J i) +
      Finsupp.single (Sum.inr (Sum.inr i)) (α (Sum.inr i) - J i))

theorem expo_inl (α : Fin d ⊕ Fin d →₀ ℕ) (J : Fin d → ℕ) (i : Fin d) :
    expo α J (Sum.inl i) = α (Sum.inl i) := by
  classical
  simp [expo, Finsupp.single_apply]

theorem expo_inr_inl (α : Fin d ⊕ Fin d →₀ ℕ) (J : Fin d → ℕ) (i : Fin d) :
    expo α J (Sum.inr (Sum.inl i)) = J i := by
  classical
  simp [expo, Finsupp.single_apply]

theorem expo_inr_inr (α : Fin d ⊕ Fin d →₀ ℕ) (J : Fin d → ℕ) (i : Fin d) :
    expo α J (Sum.inr (Sum.inr i)) = α (Sum.inr i) - J i := by
  classical
  simp [expo, Finsupp.single_apply]
  rw [Finset.sum_eq_single i (fun x _ hx => by simp [hx]) (by simp)]
  simp

theorem prod_eq_sum (α : Fin d ⊕ Fin d →₀ ℕ) :
    (α.prod fun s k => (Sum.elim x1 (fun i => (x2 i + x3 i : MvPowerSeries (Fin d ⊕ (Fin d ⊕ Fin d)) R)) s) ^ k) =
      ∑ J ∈ Fintype.piFinset (fun i => Finset.range (α (Sum.inr i) + 1)),
        monomial (expo α J) (∏ i, ((α (Sum.inr i)).choose (J i) : R)) := by
  classical
  rw [Finsupp.prod_fintype _ _ (fun _ => pow_zero _), Fintype.prod_sum_type]
  simp only [Sum.elim_inl, Sum.elim_inr, x1, x2, x3, X_pow_eq, add_pow_X', prod_monomial']
  rw [Finset.prod_univ_sum, Finset.mul_sum]
  refine Finset.sum_congr rfl fun J _ => ?_
  rw [prod_monomial', monomial_mul_monomial, Finset.prod_const_one, one_mul, expo]

end GlobalTheory.BinomRight

namespace GlobalTheory.BinomRight

variable {R : Type} [CommRing R] {d : ℕ}

theorem sumElim_eq_expo_iff (α : Fin d ⊕ Fin d →₀ ℕ) (a b e : Fin d →₀ ℕ) (J : Fin d → ℕ)
    (hJ : ∀ i, J i ≤ α (Sum.inr i)) :
    Finsupp.sumElim a (Finsupp.sumElim b e) = expo α J ↔
      α = Finsupp.sumElim a (b + e) ∧ J = ⇑b := by
  constructor
  · intro h
    have h1 := fun i => DFunLike.congr_fun h (Sum.inl i)
    have h2 := fun i => DFunLike.congr_fun h (Sum.inr (Sum.inl i))
    have h3 := fun i => DFunLike.congr_fun h (Sum.inr (Sum.inr i))
    simp only [expo_inl, expo_inr_inl, expo_inr_inr, Finsupp.sumElim_apply, Sum.elim_inl,
      Sum.elim_inr] at h1 h2 h3
    have hJb : J = ⇑b := funext fun i => (h2 i).symm
    refine ⟨Finsupp.ext fun s => ?_, hJb⟩
    rcases s with i | i
    · simp [h1 i]
    · have := h3 i; have := hJ i; have := h2 i
      simp only [Finsupp.sumElim_apply, Sum.elim_inr, Finsupp.add_apply]
      omega
  · rintro ⟨rfl, rfl⟩
    refine Finsupp.ext fun s => ?_
    rcases s with i | i | i
    · simp [expo_inl]
    · simp [expo_inr_inl]
    · simp [expo_inr_inr]

end GlobalTheory.BinomRight

namespace GlobalTheory.BinomRight

theorem coeff_prod_pow_second_add_third_threeGroups {R : Type} [CommRing R] {d : ℕ} (α : Fin d ⊕ Fin d →₀ ℕ)
    (a b e : Fin d →₀ ℕ) :
    coeff (Finsupp.sumElim a (Finsupp.sumElim b e))
        (α.prod fun s k => (Sum.elim x1
          (fun i => (x2 i + x3 i : MvPowerSeries (Fin d ⊕ (Fin d ⊕ Fin d)) R)) s) ^ k) =
      if α = Finsupp.sumElim a (b + e) then (∏ i, ((b + e) i).choose (b i) : R) else 0 := by
  classical
  rw [prod_eq_sum, map_sum]
  simp only [coeff_monomial]
  have hmem : ∀ J ∈ Fintype.piFinset (fun i => Finset.range (α (Sum.inr i) + 1)),
      ∀ i, J i ≤ α (Sum.inr i) := fun J hJ i =>
    Nat.lt_succ_iff.1 (Finset.mem_range.1 (Fintype.mem_piFinset.1 hJ i))
  by_cases hα : α = Finsupp.sumElim a (b + e)
  · rw [if_pos hα]
    have hb : ⇑b ∈ Fintype.piFinset (fun i => Finset.range (α (Sum.inr i) + 1)) := by
      refine Fintype.mem_piFinset.2 fun i => Finset.mem_range.2 ?_
      rw [hα]; simp
    rw [Finset.sum_eq_single_of_mem (⇑b) hb]
    · rw [if_pos ((sumElim_eq_expo_iff α a b e _ (hmem _ hb)).2 ⟨hα, rfl⟩)]
      refine Finset.prod_congr rfl fun i _ => ?_
      rw [hα]; simp
    · intro J hJ hJb
      rw [if_neg fun h => hJb ((sumElim_eq_expo_iff α a b e J (hmem J hJ)).1 h).2]
  · rw [if_neg hα]
    refine Finset.sum_eq_zero fun J hJ => ?_
    rw [if_neg fun h => hα ((sumElim_eq_expo_iff α a b e J (hmem J hJ)).1 h).1]

end GlobalTheory.BinomRight
