ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.weightedDegree_eq_zero_iff
theorem weightedDegree_eq_zero_iff (hw : NonTorsionWeight w) {m : σ →₀ ℕ} :
    weight w m = 0 ↔ ∀ x : σ, m x = 0 
Arguments: {M : Type u_2} {σ : Type u_3} [CanonicallyLinearOrderedAddCommMonoid M] {w : σ → M} (hw : MvPolynomial.NonTorsionWeight w) {m : σ →₀ ℕ}
Goal: (Finsupp.weight w) m = 0 ↔ ∀ (x : σ), m x = 0
-- MvPolynomial.isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero
theorem isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero {p : MvPolynomial σ R} :
    IsWeightedHomogeneous w p 0 ↔ p.weightedTotalDegree w = 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] {σ : Type u_3} [CanonicallyLinearOrderedAddCommMonoid M] {w : σ → M} {p : MvPolynomial σ R}
Goal: MvPolynomial.IsWeightedHomogeneous w p 0 ↔ MvPolynomial.weightedTotalDegree w p = 0
-- MvPolynomial.weightedTotalDegree_eq_zero_iff
theorem weightedTotalDegree_eq_zero_iff (hw : NonTorsionWeight w) (p : MvPolynomial σ R) :
    p.weightedTotalDegree w = 0 ↔ ∀ (m : σ →₀ ℕ) (_ : m ∈ p.support) (x : σ), m x = 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] {σ : Type u_3} [CanonicallyLinearOrderedAddCommMonoid M] {w : σ → M} (hw : MvPolynomial.NonTorsionWeight w) (p : MvPolynomial σ R)
Goal: MvPolynomial.weightedTotalDegree w p = 0 ↔ ∀ m ∈ p.support, ∀ (x : σ), m x = 0
-- MvPolynomial.weightedHomogeneousComponent_eq_zero_of_not_mem
theorem weightedHomogeneousComponent_eq_zero_of_not_mem [DecidableEq M]
    (φ : MvPolynomial σ R) (i : M) (hi : i ∉ Finset.image (weight w) φ.support) :
    weightedHomogeneousComponent w i φ = 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] {σ : Type u_3} (w : σ → M) [AddCommMonoid M] [DecidableEq M] (φ : MvPolynomial σ R) (i : M) (hi : i ∉ Finset.image (⇑(Finsupp.weight w)) φ.support)
Goal: (MvPolynomial.weightedHomogeneousComponent w i) φ = 0
-- MvPolynomial.decompose'_apply
theorem decompose'_apply [DecidableEq M] (φ : MvPolynomial σ R) (m : M) :
    (decompose' R w φ m : MvPolynomial σ R) = weightedHomogeneousComponent w m φ 
Arguments: (R : Type u_1) {M : Type u_2} [CommSemiring R] {σ : Type u_3} (w : σ → M) [AddCommMonoid M] [DecidableEq M] (φ : MvPolynomial σ R) (m : M)
Goal: ↑((MvPolynomial.decompose' R w φ) m) = (MvPolynomial.weightedHomogeneousComponent w m) φ
-- MvPolynomial.weightedDecomposition.decompose'_eq
theorem weightedDecomposition.decompose'_eq [DecidableEq M] :
    (weightedDecomposition R w).decompose' = fun φ : MvPolynomial σ R =>
      DirectSum.mk (fun i : M => ↥(weightedHomogeneousSubmodule R w i))
        (Finset.image (weight w) φ.support) fun m =>
          ⟨weightedHomogeneousComponent w m φ, weightedHomogeneousComponent_mem w φ m⟩ 
Arguments: (R : Type u_1) {M : Type u_2} [CommSemiring R] {σ : Type u_3} (w : σ → M) [AddCommMonoid M] [DecidableEq M]
Goal: DirectSum.Decomposition.decompose' = fun φ =>
  (DirectSum.mk (fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i))
      (Finset.image (⇑(Finsupp.weight w)) φ.support))
    fun m => ⟨(MvPolynomial.weightedHomogeneousComponent w ↑m) φ, ⋯⟩
-- MvPolynomial.weightedDecomposition.decompose'_apply
theorem weightedDecomposition.decompose'_apply [DecidableEq M]
    (φ : MvPolynomial σ R) (m : M) :
    ((weightedDecomposition R w).decompose' φ m : MvPolynomial σ R) =
      weightedHomogeneousComponent w m φ 
Arguments: (R : Type u_1) {M : Type u_2} [CommSemiring R] {σ : Type u_3} (w : σ → M) [AddCommMonoid M] [DecidableEq M] (φ : MvPolynomial σ R) (m : M)
Goal: ↑((DirectSum.Decomposition.decompose' φ) m) = (MvPolynomial.weightedHomogeneousComponent w m) φ
-- Algebra.EssFiniteType.cond
class EssFiniteType : Prop where
  cond : ∃ s : Finset S,
    IsLocalization ((IsUnit.submonoid S).comap (algebraMap (adjoin R (s : Set S)) S)) S
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] [self : Algebra.EssFiniteType R S]
Goal: ∃ s, IsLocalization (Submonoid.comap (algebraMap (↥(Algebra.adjoin R ↑s)) S) (IsUnit.submonoid S)) S
-- Algebra.EssFiniteType.adjoin_mem_finset
lemma EssFiniteType.adjoin_mem_finset [EssFiniteType R S] :
    adjoin R { x : subalgebra R S | x.1 ∈ finset R S } = ⊤ 
Arguments: (R : Type u_1) (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] [Algebra.EssFiniteType R S]
Goal: Algebra.adjoin R {x | ↑x ∈ Algebra.EssFiniteType.finset R S} = ⊤
-- Algebra.essFiniteType_cond_iff
lemma essFiniteType_cond_iff (σ : Finset S) :
    IsLocalization ((IsUnit.submonoid S).comap (algebraMap (adjoin R (σ : Set S)) S)) S ↔
    (∀ s : S, ∃ t ∈ Algebra.adjoin R (σ : Set S),
      IsUnit t ∧ s * t ∈ Algebra.adjoin R (σ : Set S)) 
Arguments: (R : Type u_1) (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] (σ : Finset S)
Goal: IsLocalization (Submonoid.comap (algebraMap (↥(Algebra.adjoin R ↑σ)) S) (IsUnit.submonoid S)) S ↔
  ∀ (s : S), ∃ t ∈ Algebra.adjoin R ↑σ, IsUnit t ∧ s * t ∈ Algebra.adjoin R ↑σ
-- Algebra.essFiniteType_iff
lemma essFiniteType_iff :
    EssFiniteType R S ↔ ∃ (σ : Finset S),
      (∀ s : S, ∃ t ∈ Algebra.adjoin R (σ : Set S),
        IsUnit t ∧ s * t ∈ Algebra.adjoin R (σ : Set S)) 
Arguments: (R : Type u_1) (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S]
Goal: Algebra.EssFiniteType R S ↔ ∃ σ, ∀ (s : S), ∃ t ∈ Algebra.adjoin R ↑σ, IsUnit t ∧ s * t ∈ Algebra.adjoin R ↑σ
-- Algebra.EssFiniteType.of_isLocalization
lemma EssFiniteType.of_isLocalization (M : Submonoid R) [IsLocalization M S] :
    EssFiniteType R S 
Arguments: {R : Type u_1} (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] (M : Submonoid R) [IsLocalization M S]
Goal: Algebra.EssFiniteType R S
-- Algebra.EssFiniteType.of_id
lemma EssFiniteType.of_id : EssFiniteType R R 
Arguments: (R : Type u_1) [CommRing R]
Goal: Algebra.EssFiniteType R R
-- Algebra.EssFiniteType.aux
lemma EssFiniteType.aux (σ : Subalgebra R S)
    (hσ : ∀ s : S, ∃ t ∈ σ, IsUnit t ∧ s * t ∈ σ)
    (τ : Set T) (t : T) (ht : t ∈ Algebra.adjoin S τ) :
    ∃ s ∈ σ, IsUnit s ∧ s • t ∈ σ.map (IsScalarTower.toAlgHom R S T) ⊔ Algebra.adjoin R τ 
Arguments: (R : Type u_1) (S : Type u_2) (T : Type u_3) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] (σ : Subalgebra R S) (hσ : ∀ (s : S), ∃ t ∈ σ, IsUnit t ∧ s * t ∈ σ) (τ : Set T) (t : T) (ht : t ∈ Algebra.adjoin S τ)
Goal: ∃ s ∈ σ, IsUnit s ∧ s • t ∈ Subalgebra.map (IsScalarTower.toAlgHom R S T) σ ⊔ Algebra.adjoin R τ
-- Algebra.EssFiniteType.comp
lemma EssFiniteType.comp [h₁ : EssFiniteType R S] [h₂ : EssFiniteType S T] :
    EssFiniteType R T 
Arguments: (R : Type u_1) (S : Type u_2) (T : Type u_3) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] [h₁ : Algebra.EssFiniteType R S] [h₂ : Algebra.EssFiniteType S T]
Goal: Algebra.EssFiniteType R T
-- Algebra.essFiniteType_iff_exists_subalgebra
lemma essFiniteType_iff_exists_subalgebra : EssFiniteType R S ↔
    ∃ (S₀ : Subalgebra R S) (M : Submonoid S₀), FiniteType R S₀ ∧ IsLocalization M S 
Arguments: (R : Type u_1) (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S]
Goal: Algebra.EssFiniteType R S ↔ ∃ S₀ M, Algebra.FiniteType R ↥S₀ ∧ IsLocalization M S
-- Algebra.EssFiniteType.of_comp
lemma EssFiniteType.of_comp [h : EssFiniteType R T] : EssFiniteType S T 
Arguments: (R : Type u_1) (S : Type u_2) (T : Type u_3) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] [h : Algebra.EssFiniteType R T]
Goal: Algebra.EssFiniteType S T
-- Algebra.EssFiniteType.comp_iff
lemma EssFiniteType.comp_iff [EssFiniteType R S] :
    EssFiniteType R T ↔ EssFiniteType S T 
Arguments: (R : Type u_1) (S : Type u_2) (T : Type u_3) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] [Algebra.EssFiniteType R S]
Goal: Algebra.EssFiniteType R T ↔ Algebra.EssFiniteType S T
-- Algebra.EssFiniteType.algHom_ext
lemma EssFiniteType.algHom_ext [EssFiniteType R S]
    (f g : S →ₐ[R] T) (H : ∀ s ∈ finset R S, f s = g s) : f = g 
Arguments: {R : Type u_1} {S : Type u_2} (T : Type u_3) [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra.EssFiniteType R S] (f g : S →ₐ[R] T) (H : ∀ s ∈ Algebra.EssFiniteType.finset R S, f s = g s)
Goal: f = g
-- IsPrimitiveRoot.isIntegral
-- Porting note: `hpos` was in the `variable` line, with an `omit` in mathlib3 just after this
-- declaration. For some reason, in Lean4, `hpos` gets included also in the declarations below,
-- even if it is not used in the proof.
theorem isIntegral (hpos : 0 < n) : IsIntegral ℤ μ 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) (hpos : 0 < n)
Goal: IsIntegral ℤ μ
-- IsPrimitiveRoot.minpoly_dvd_x_pow_sub_one
theorem minpoly_dvd_x_pow_sub_one : minpoly ℤ μ ∣ X ^ n - 1 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K]
Goal: minpoly ℤ μ ∣ Polynomial.X ^ n - 1
-- IsPrimitiveRoot.separable_minpoly_mod
theorem separable_minpoly_mod {p : ℕ} [Fact p.Prime] (hdiv : ¬p ∣ n) :
    Separable (map (Int.castRingHom (ZMod p)) (minpoly ℤ μ)) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} [Fact (Nat.Prime p)] (hdiv : ¬p ∣ n)
Goal: (Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ)).Separable
-- IsPrimitiveRoot.squarefree_minpoly_mod
theorem squarefree_minpoly_mod {p : ℕ} [Fact p.Prime] (hdiv : ¬p ∣ n) :
    Squarefree (map (Int.castRingHom (ZMod p)) (minpoly ℤ μ)) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} [Fact (Nat.Prime p)] (hdiv : ¬p ∣ n)
Goal: Squarefree (Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ))
-- IsPrimitiveRoot.minpoly_dvd_expand
theorem minpoly_dvd_expand {p : ℕ} (hdiv : ¬p ∣ n) :
    minpoly ℤ μ ∣ expand ℤ p (minpoly ℤ (μ ^ p)) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} (hdiv : ¬p ∣ n)
Goal: minpoly ℤ μ ∣ (Polynomial.expand ℤ p) (minpoly ℤ (μ ^ p))
-- IsPrimitiveRoot.minpoly_dvd_pow_mod
theorem minpoly_dvd_pow_mod {p : ℕ} [hprime : Fact p.Prime] (hdiv : ¬p ∣ n) :
    map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
      map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) ^ p 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} [hprime : Fact (Nat.Prime p)] (hdiv : ¬p ∣ n)
Goal: Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
  Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) ^ p
-- IsPrimitiveRoot.minpoly_dvd_mod_p
theorem minpoly_dvd_mod_p {p : ℕ} [Fact p.Prime] (hdiv : ¬p ∣ n) :
    map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
      map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} [Fact (Nat.Prime p)] (hdiv : ¬p ∣ n)
Goal: Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣ Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p))
-- IsPrimitiveRoot.minpoly_eq_pow
theorem minpoly_eq_pow {p : ℕ} [hprime : Fact p.Prime] (hdiv : ¬p ∣ n) :
    minpoly ℤ μ = minpoly ℤ (μ ^ p) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {p : ℕ} [hprime : Fact (Nat.Prime p)] (hdiv : ¬p ∣ n)
Goal: minpoly ℤ μ = minpoly ℤ (μ ^ p)
-- IsPrimitiveRoot.minpoly_eq_pow_coprime
theorem minpoly_eq_pow_coprime {m : ℕ} (hcop : Nat.Coprime m n) :
    minpoly ℤ μ = minpoly ℤ (μ ^ m) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {m : ℕ} (hcop : m.Coprime n)
Goal: minpoly ℤ μ = minpoly ℤ (μ ^ m)
-- IsPrimitiveRoot.pow_isRoot_minpoly
theorem pow_isRoot_minpoly {m : ℕ} (hcop : Nat.Coprime m n) :
    IsRoot (map (Int.castRingHom K) (minpoly ℤ μ)) (μ ^ m) 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] {m : ℕ} (hcop : m.Coprime n)
Goal: (Polynomial.map (Int.castRingHom K) (minpoly ℤ μ)).IsRoot (μ ^ m)
-- IsPrimitiveRoot.is_roots_of_minpoly
theorem is_roots_of_minpoly [DecidableEq K] :
    primitiveRoots n K ⊆ (map (Int.castRingHom K) (minpoly ℤ μ)).roots.toFinset 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K] [DecidableEq K]
Goal: primitiveRoots n K ⊆ (Polynomial.map (Int.castRingHom K) (minpoly ℤ μ)).roots.toFinset
-- IsPrimitiveRoot.totient_le_degree_minpoly
theorem totient_le_degree_minpoly : Nat.totient n ≤ (minpoly ℤ μ).natDegree 
Arguments: {n : ℕ} {K : Type u_1} [CommRing K] {μ : K} (h : IsPrimitiveRoot μ n) [IsDomain K] [CharZero K]
Goal: n.totient ≤ (minpoly ℤ μ).natDegree
-- Ring.DimensionLEOne.maximalOfPrime
class Ring.DimensionLEOne : Prop :=
  (maximalOfPrime : ∀ {p : Ideal R}, p ≠ ⊥ → p.IsPrime → p.IsMaximal)
Arguments: {R : Type u_1} [CommRing R] [self : Ring.DimensionLEOne R] {p : Ideal R}
Goal: p ≠ ⊥ → p.IsPrime → p.IsMaximal
-- Ideal.IsPrime.isMaximal
theorem Ideal.IsPrime.isMaximal {R : Type*} [CommRing R] [DimensionLEOne R]
    {p : Ideal R} (h : p.IsPrime) (hp : p ≠ ⊥) : p.IsMaximal 
Arguments: {R : Type u_4} [CommRing R] [Ring.DimensionLEOne R] {p : Ideal R} (h : p.IsPrime) (hp : p ≠ ⊥)
Goal: p.IsMaximal
-- Ring.DimensionLEOne.isIntegralClosure
theorem DimensionLEOne.isIntegralClosure (B : Type*) [CommRing B] [IsDomain B] [Nontrivial R]
    [Algebra R A] [Algebra R B] [Algebra B A] [IsScalarTower R B A] [IsIntegralClosure B R A]
    [DimensionLEOne R] : DimensionLEOne B 
Arguments: (R : Type u_1) (A : Type u_2) [CommRing R] [CommRing A] (B : Type u_4) [CommRing B] [IsDomain B] [Nontrivial R] [Algebra R A] [Algebra R B] [Algebra B A] [IsScalarTower R B A] [IsIntegralClosure B R A] [Ring.DimensionLEOne R]
Goal: Ring.DimensionLEOne B
-- Ring.DimensionLEOne.not_lt_lt
theorem DimensionLEOne.not_lt_lt [Ring.DimensionLEOne R] (p₀ p₁ p₂ : Ideal R) [hp₁ : p₁.IsPrime]
    [hp₂ : p₂.IsPrime] : ¬(p₀ < p₁ ∧ p₁ < p₂)
  
Arguments: {R : Type u_1} [CommRing R] [Ring.DimensionLEOne R] (p₀ p₁ p₂ : Ideal R) [hp₁ : p₁.IsPrime] [hp₂ : p₂.IsPrime]
Goal: ¬(p₀ < p₁ ∧ p₁ < p₂)
-- Ring.DimensionLEOne.eq_bot_of_lt
theorem DimensionLEOne.eq_bot_of_lt [Ring.DimensionLEOne R] (p P : Ideal R) [p.IsPrime]
    [P.IsPrime] (hpP : p < P) : p = ⊥ 
Arguments: {R : Type u_1} [CommRing R] [Ring.DimensionLEOne R] (p P : Ideal R) [p.IsPrime] [P.IsPrime] (hpP : p < P)
Goal: p = ⊥
-- isDedekindRing_iff
theorem isDedekindRing_iff (K : Type*) [CommRing K] [Algebra A K] [IsFractionRing A K] :
    IsDedekindRing A ↔
      IsNoetherianRing A ∧ DimensionLEOne A ∧
        ∀ {x : K}, IsIntegral A x → ∃ y, algebraMap A K y = x 
Arguments: (A : Type u_2) [CommRing A] (K : Type u_4) [CommRing K] [Algebra A K] [IsFractionRing A K]
Goal: IsDedekindRing A ↔ IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x
-- isDedekindDomain_iff
theorem isDedekindDomain_iff (K : Type*) [Field K] [Algebra A K] [IsFractionRing A K] :
    IsDedekindDomain A ↔
      IsDomain A ∧ IsNoetherianRing A ∧ DimensionLEOne A ∧
        ∀ {x : K}, IsIntegral A x → ∃ y, algebraMap A K y = x 
Arguments: (A : Type u_2) [CommRing A] (K : Type u_4) [Field K] [Algebra A K] [IsFractionRing A K]
Goal: IsDedekindDomain A ↔
  IsDomain A ∧ IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.mem_pairs
@[simp]
private lemma mem_pairs (k : ℕ) (t : Finset σ × σ) :
    t ∈ pairs σ k ↔ card t.fst ≤ k ∧ (card t.fst = k → t.snd ∈ t.fst) 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (k : ℕ) (t : Finset σ × σ)
Goal: t ∈ MvPolynomial.NewtonIdentities.pairs σ k ↔ t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_ne_self
private lemma pairMap_ne_self (t : Finset σ × σ) : pairMap σ t ≠ t 
Arguments: (σ : Type u_1) [DecidableEq σ] (t : Finset σ × σ)
Goal: MvPolynomial.NewtonIdentities.pairMap σ t ≠ t
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_of_snd_mem_fst
private lemma pairMap_of_snd_mem_fst {t : Finset σ × σ} (h : t.snd ∈ t.fst) :
    pairMap σ t = (t.fst.erase t.snd, t.snd) 
Arguments: (σ : Type u_1) [DecidableEq σ] {t : Finset σ × σ} (h : t.2 ∈ t.1)
Goal: MvPolynomial.NewtonIdentities.pairMap σ t = (t.1.erase t.2, t.2)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_of_snd_nmem_fst
private lemma pairMap_of_snd_nmem_fst {t : Finset σ × σ} (h : t.snd ∉ t.fst) :
    pairMap σ t = (t.fst.cons t.snd h, t.snd) 
Arguments: (σ : Type u_1) [DecidableEq σ] {t : Finset σ × σ} (h : t.2 ∉ t.1)
Goal: MvPolynomial.NewtonIdentities.pairMap σ t = (Finset.cons t.2 t.1 h, t.2)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs
private theorem pairMap_mem_pairs {k : ℕ} (t : Finset σ × σ) (h : t ∈ pairs σ k) :
    pairMap σ t ∈ pairs σ k 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] {k : ℕ} (t : Finset σ × σ) (h : t ∈ MvPolynomial.NewtonIdentities.pairs σ k)
Goal: MvPolynomial.NewtonIdentities.pairMap σ t ∈ MvPolynomial.NewtonIdentities.pairs σ k
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_involutive
@[simp]
private theorem pairMap_involutive : (pairMap σ).Involutive 
Arguments: (σ : Type u_1) [DecidableEq σ]
Goal: Function.Involutive (MvPolynomial.NewtonIdentities.pairMap σ)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.weight_add_weight_pairMap
private theorem weight_add_weight_pairMap {k : ℕ} (t : Finset σ × σ) (h : t ∈ pairs σ k) :
    weight σ R k t + weight σ R k (pairMap σ t) = 0 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] {k : ℕ} (t : Finset σ × σ) (h : t ∈ MvPolynomial.NewtonIdentities.pairs σ k)
Goal: MvPolynomial.NewtonIdentities.weight σ R k t +
    MvPolynomial.NewtonIdentities.weight σ R k (MvPolynomial.NewtonIdentities.pairMap σ t) =
  0
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.weight_sum
private theorem weight_sum (k : ℕ) : ∑ t ∈ pairs σ k, weight σ R k t = 0 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] (k : ℕ)
Goal: ∑ t ∈ MvPolynomial.NewtonIdentities.pairs σ k, MvPolynomial.NewtonIdentities.weight σ R k t = 0
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_powersetCard_sum
private theorem sum_filter_pairs_eq_sum_powersetCard_sum (k : ℕ)
    (f : Finset σ × σ → MvPolynomial σ R) :
    (∑ t ∈ filter (fun t ↦ card t.fst = k) (pairs σ k), f t) =
    ∑ A ∈ powersetCard k univ, (∑ j ∈ A, f (A, j)) 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] (k : ℕ) (f : Finset σ × σ → MvPolynomial σ R)
Goal: ∑ t ∈ Finset.filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
  ∑ A ∈ Finset.powersetCard k Finset.univ, ∑ j ∈ A, f (A, j)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_powersetCard_mem_filter_antidiagonal_sum
private theorem sum_filter_pairs_eq_sum_powersetCard_mem_filter_antidiagonal_sum (k : ℕ) (a : ℕ × ℕ)
    (ha : a ∈ (antidiagonal k).filter (fun a ↦ a.fst < k)) (f : Finset σ × σ → MvPolynomial σ R) :
    (∑ t ∈ filter (fun t ↦ card t.fst = a.fst) (pairs σ k), f t) =
    ∑ A ∈ powersetCard a.fst univ, (∑ j, f (A, j)) 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] (k : ℕ) (a : ℕ × ℕ) (ha : a ∈ Finset.filter (fun a => a.1 < k) (Finset.antidiagonal k)) (f : Finset σ × σ → MvPolynomial σ R)
Goal: ∑ t ∈ Finset.filter (fun t => t.1.card = a.1) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
  ∑ A ∈ Finset.powersetCard a.1 Finset.univ, ∑ j : σ, f (A, j)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.filter_pairs_lt
private lemma filter_pairs_lt (k : ℕ) :
    (pairs σ k).filter (fun (s, _) ↦ s.card < k) =
      (range k).disjiUnion (powersetCard · univ) ((pairwise_disjoint_powersetCard _).set_pairwise _)
        ×ˢ univ 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (k : ℕ)
Goal: Finset.filter
    (fun x =>
      match x with
      | (s, snd) => s.card < k)
    (MvPolynomial.NewtonIdentities.pairs σ k) =
  (Finset.range k).disjiUnion (fun x => Finset.powersetCard x Finset.univ) ⋯ ×ˢ Finset.univ
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_filter_antidiagonal_powersetCard_sum
private theorem sum_filter_pairs_eq_sum_filter_antidiagonal_powersetCard_sum (k : ℕ)
    (f : Finset σ × σ → MvPolynomial σ R) :
    ∑ t ∈ (pairs σ k).filter fun t ↦ card t.fst < k, f t =
      ∑ a ∈ (antidiagonal k).filter fun a ↦ a.fst < k,
        ∑ A ∈ powersetCard a.fst univ, ∑ j, f (A, j) 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] (k : ℕ) (f : Finset σ × σ → MvPolynomial σ R)
Goal: ∑ t ∈ Finset.filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
  ∑ a ∈ Finset.filter (fun a => a.1 < k) (Finset.antidiagonal k),
    ∑ A ∈ Finset.powersetCard a.1 Finset.univ, ∑ j : σ, f (A, j)
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.disjoint_filter_pairs_lt_filter_pairs_eq
private theorem disjoint_filter_pairs_lt_filter_pairs_eq (k : ℕ) :
    Disjoint (filter (fun t ↦ card t.fst < k) (pairs σ k))
    (filter (fun t ↦ card t.fst = k) (pairs σ k)) 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (k : ℕ)
Goal: Disjoint (Finset.filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k))
  (Finset.filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k))
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.disjUnion_filter_pairs_eq_pairs
private theorem disjUnion_filter_pairs_eq_pairs (k : ℕ) :
    disjUnion (filter (fun t ↦ card t.fst < k) (pairs σ k))
    (filter (fun t ↦ card t.fst = k) (pairs σ k)) (disjoint_filter_pairs_lt_filter_pairs_eq σ k) =
    pairs σ k 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (k : ℕ)
Goal: (Finset.filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k)).disjUnion
    (Finset.filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k)) ⋯ =
  MvPolynomial.NewtonIdentities.pairs σ k
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.esymm_summand_to_weight
private theorem esymm_summand_to_weight (k : ℕ) (A : Finset σ) (h : A ∈ powersetCard k univ) :
    ∑ j ∈ A, weight σ R k (A, j) = k * (-1) ^ k * (∏ i ∈ A, X i : MvPolynomial σ R) 
Arguments: (σ : Type u_1) [Fintype σ] (R : Type u_2) [CommRing R] (k : ℕ) (A : Finset σ) (h : A ∈ Finset.powersetCard k Finset.univ)
Goal: ∑ j ∈ A, MvPolynomial.NewtonIdentities.weight σ R k (A, j) = ↑k * (-1) ^ k * ∏ i ∈ A, MvPolynomial.X i
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.esymm_to_weight
private theorem esymm_to_weight (k : ℕ) : k * esymm σ R k =
    (-1) ^ k * ∑ t ∈ filter (fun t ↦ card t.fst = k) (pairs σ k), weight σ R k t 
Arguments: (σ : Type u_1) [Fintype σ] [DecidableEq σ] (R : Type u_2) [CommRing R] (k : ℕ)
Goal: ↑k * MvPolynomial.esymm σ R k =
  (-1) ^ k *
    ∑ t ∈ Finset.filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k),
      MvPolynomial.NewtonIdentities.weight σ R k t
-- _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.esymm_mul_psum_summand_to_weight
private theorem esymm_mul_psum_summand_to_weight (k : ℕ) (a : ℕ × ℕ) (ha : a ∈ antidiagonal k) :
    ∑ A ∈ powersetCard a.fst univ, ∑ j, weight σ R k (A, j) =
    (-1) ^ a.fst * esymm σ R a.fst * psum σ R a.snd 
Arguments: (σ : Type u_1) [Fintype σ] (R : Type u_2) [CommRing R] (k : ℕ) (a : ℕ × ℕ) (ha : a ∈ Finset.antidiagonal k)
Goal: ∑ A ∈ Finset.powersetCard a.1 Finset.univ, ∑ j : σ, MvPolynomial.NewtonIdentities.weight σ R k (A, j) =
  (-1) ^ a.1 * MvPolynomial.esymm σ R a.1 * MvPolynomial.psum σ R a.2