fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
protected isLocalRing {A B : Type*} [CommSemiring A] [IsLocalRing A] [Semiring B]
(e : A ≃+* B) : IsLocalRing B :=
haveI := e.symm.toEquiv.nontrivial
IsLocalRing.of_surjective (e : A →+* B) e.surjective | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | isLocalRing | null |
degree_degLexDegree : (degLex.degree f).degree = f.totalDegree := by
by_cases hf : f = 0
· simp [hf]
apply le_antisymm
· exact le_totalDegree (degLex.degree_mem_support hf)
· unfold MvPolynomial.totalDegree
apply Finset.sup_le
intro b hb
exact DegLex.monotone_degree (degLex.le_degree hb) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.MonomialOrder",
"Mathlib.Data.Finsupp.MonomialOrder.DegLex"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder/DegLex.lean | degree_degLexDegree | null |
degLex_totalDegree_monotone (h : degLex.degree f ≼[degLex] degLex.degree g) :
f.totalDegree ≤ g.totalDegree := by
simp only [← MvPolynomial.degree_degLexDegree]
exact DegLex.monotone_degree h | theorem | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.MonomialOrder",
"Mathlib.Data.Finsupp.MonomialOrder.DegLex"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder/DegLex.lean | degLex_totalDegree_monotone | null |
totalDegree_mul_of_isDomain [IsCancelMulZero R] (hf : f ≠ 0) (hg : g ≠ 0) :
totalDegree (f * g) = totalDegree f + totalDegree g := by
cases exists_wellOrder σ
rw [← degree_degLexDegree (σ := σᵒᵈ), ← degree_degLexDegree (σ := σᵒᵈ),
← degree_degLexDegree (σ := σᵒᵈ), MonomialOrder.degree_mul hf hg]
simp | theorem | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.MonomialOrder",
"Mathlib.Data.Finsupp.MonomialOrder.DegLex"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder/DegLex.lean | totalDegree_mul_of_isDomain | null |
esymm (s : Multiset R) (n : ℕ) : R :=
((s.powersetCard n).map Multiset.prod).sum | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm | The `n`th elementary symmetric function evaluated at the elements of `s` |
_root_.Finset.esymm_map_val {σ} (f : σ → R) (s : Finset σ) (n : ℕ) :
(s.val.map f).esymm n = (s.powersetCard n).sum fun t => t.prod f := by
simp only [esymm, powersetCard_map, ← Finset.map_val_val_powersetCard, map_map]
simp only [Function.comp_apply, Finset.prod_map_val, Finset.sum_map_val] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | _root_.Finset.esymm_map_val | null |
pow_smul_esymm {S : Type*} [Monoid S] [DistribMulAction S R] [IsScalarTower S R R]
[SMulCommClass S R R] (s : S) (n : ℕ) (m : Multiset R) :
s ^ n • m.esymm n = (m.map (s • ·)).esymm n := by
rw [esymm, smul_sum, map_map]
trans ((powersetCard n m).map (fun x : Multiset R ↦ s ^ card x • x.prod)).sum
· refine congr_arg _ (map_congr rfl (fun x hx ↦ ?_))
rw [Function.comp_apply, (mem_powersetCard.1 hx).2]
· simp_rw [smul_prod, esymm, powersetCard_map, map_map, Function.comp_def]
@[simp] lemma esymm_pair_one (x y : R) :
esymm (x ::ₘ {y}) 1 = x + y := by
simp [esymm, powersetCard_one, add_comm]
@[simp] lemma esymm_pair_two (x y : R) :
esymm (x ::ₘ {y}) 2 = x * y := by
simp [esymm, powersetCard_one] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | pow_smul_esymm | null |
IsSymmetric [CommSemiring R] (φ : MvPolynomial σ R) : Prop :=
∀ e : Perm σ, rename e φ = φ | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | IsSymmetric | A `MvPolynomial φ` is symmetric if it is invariant under
permutations of its variables by the `rename` operation |
symmetricSubalgebra (σ R : Type*) [CommSemiring R] : Subalgebra R (MvPolynomial σ R) where
carrier := setOf IsSymmetric
algebraMap_mem' r e := rename_C e r
mul_mem' ha hb e := by rw [map_mul, ha, hb]
add_mem' ha hb e := by rw [map_add, ha, hb]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | symmetricSubalgebra | The subalgebra of symmetric `MvPolynomial`s. |
mem_symmetricSubalgebra [CommSemiring R] (p : MvPolynomial σ R) :
p ∈ symmetricSubalgebra σ R ↔ p.IsSymmetric :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | mem_symmetricSubalgebra | null |
@[simp]
C (r : R) : IsSymmetric (C r : MvPolynomial σ R) :=
(symmetricSubalgebra σ R).algebraMap_mem r
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | C | null |
zero : IsSymmetric (0 : MvPolynomial σ R) :=
(symmetricSubalgebra σ R).zero_mem
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | zero | null |
one : IsSymmetric (1 : MvPolynomial σ R) :=
(symmetricSubalgebra σ R).one_mem | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | one | null |
add (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ + ψ) :=
(symmetricSubalgebra σ R).add_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | add | null |
mul (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ * ψ) :=
(symmetricSubalgebra σ R).mul_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | mul | null |
smul (r : R) (hφ : IsSymmetric φ) : IsSymmetric (r • φ) :=
(symmetricSubalgebra σ R).smul_mem hφ r
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | smul | null |
map (hφ : IsSymmetric φ) (f : R →+* S) : IsSymmetric (map f φ) := fun e => by
rw [← map_rename, hφ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | map | null |
protected rename (hφ : φ.IsSymmetric) (e : σ ≃ τ) : (rename e φ).IsSymmetric := fun _ => by
apply rename_injective _ e.symm.injective
simp_rw [rename_rename, ← Equiv.coe_trans, Equiv.self_trans_symm, Equiv.coe_refl, rename_id_apply]
rw [hφ]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | rename | null |
_root_.MvPolynomial.isSymmetric_rename {e : σ ≃ τ} :
(MvPolynomial.rename e φ).IsSymmetric ↔ φ.IsSymmetric :=
⟨fun h => by simpa using (IsSymmetric.rename (R := R) h e.symm), (IsSymmetric.rename · e)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | _root_.MvPolynomial.isSymmetric_rename | null |
neg (hφ : IsSymmetric φ) : IsSymmetric (-φ) :=
(symmetricSubalgebra σ R).neg_mem hφ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | neg | null |
sub (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ - ψ) :=
(symmetricSubalgebra σ R).sub_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | sub | null |
@[simps!]
renameSymmetricSubalgebra [CommSemiring R] (e : σ ≃ τ) :
symmetricSubalgebra σ R ≃ₐ[R] symmetricSubalgebra τ R :=
AlgEquiv.ofAlgHom
(((rename e).comp (symmetricSubalgebra σ R).val).codRestrict _ <| fun x => x.2.rename e)
(((rename e.symm).comp <| Subalgebra.val _).codRestrict _ <| fun x => x.2.rename e.symm)
(AlgHom.ext <| fun p => Subtype.ext <| by simp)
(AlgHom.ext <| fun p => Subtype.ext <| by simp)
variable (σ R : Type*) [CommSemiring R] [CommSemiring S] [Fintype σ] [Fintype τ] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | renameSymmetricSubalgebra | `MvPolynomial.rename` induces an isomorphism between the symmetric subalgebras. |
esymm (n : ℕ) : MvPolynomial σ R :=
∑ t ∈ powersetCard n univ, ∏ i ∈ t, X i | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm | The `n`th elementary symmetric `MvPolynomial σ R`.
It is the sum over all the degree n squarefree monomials in `MvPolynomial σ R`. |
esymmPart {n : ℕ} (μ : n.Partition) : MvPolynomial σ R := (μ.parts.map (esymm σ R)).prod | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymmPart | `esymmPart` is the product of the symmetric polynomials `esymm μᵢ`,
where `μ = (μ₁, μ₂, ...)` is a partition. |
esymm_eq_multiset_esymm : esymm σ R = (univ.val.map X).esymm := by
exact funext fun n => (esymm_map_val X _ n).symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_eq_multiset_esymm | The `n`th elementary symmetric `MvPolynomial σ R` is obtained by evaluating the
`n`th elementary symmetric at the `Multiset` of the monomials |
aeval_esymm_eq_multiset_esymm [Algebra R S] (n : ℕ) (f : σ → S) :
aeval f (esymm σ R n) = (univ.val.map f).esymm n := by
simp_rw [esymm, aeval_sum, aeval_prod, aeval_X, esymm_map_val] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | aeval_esymm_eq_multiset_esymm | null |
esymm_eq_sum_subtype (n : ℕ) :
esymm σ R n = ∑ t : {s : Finset σ // #s = n}, ∏ i ∈ (t : Finset σ), X i :=
sum_subtype _ (fun _ => mem_powersetCard_univ) _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_eq_sum_subtype | We can define `esymm σ R n` by summing over a subtype instead of over `powerset_len`. |
esymm_eq_sum_monomial (n : ℕ) :
esymm σ R n = ∑ t ∈ powersetCard n univ, monomial (∑ i ∈ t, Finsupp.single i 1) 1 := by
simp_rw [monomial_sum_one, esymm, ← X_pow_eq_monomial, pow_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_eq_sum_monomial | We can define `esymm σ R n` as a sum over explicit monomials |
esymm_zero : esymm σ R 0 = 1 := by
simp only [esymm, powersetCard_zero, sum_singleton, prod_empty]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_zero | null |
esymm_one : esymm σ R 1 = ∑ i, X i := by simp [esymm, powersetCard_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_one | null |
esymmPart_zero : esymmPart σ R (.indiscrete 0) = 1 := by simp [esymmPart]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymmPart_zero | null |
esymmPart_indiscrete (n : ℕ) : esymmPart σ R (.indiscrete n) = esymm σ R n := by
cases n <;> simp [esymmPart] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymmPart_indiscrete | null |
map_esymm (n : ℕ) (f : R →+* S) : map f (esymm σ R n) = esymm σ S n := by
simp_rw [esymm, map_sum, map_prod, map_X] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | map_esymm | null |
rename_esymm (n : ℕ) (e : σ ≃ τ) : rename e (esymm σ R n) = esymm τ R n :=
calc
rename e (esymm σ R n) = ∑ x ∈ powersetCard n univ, ∏ i ∈ x, X (e i) := by
simp_rw [esymm, map_sum, map_prod, rename_X]
_ = ∑ t ∈ powersetCard n (univ.map e.toEmbedding), ∏ i ∈ t, X i := by
simp [powersetCard_map, -map_univ_equiv, (mapEmbedding_apply)]
_ = ∑ t ∈ powersetCard n univ, ∏ i ∈ t, X i := by rw [map_univ_equiv] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | rename_esymm | null |
esymm_isSymmetric (n : ℕ) : IsSymmetric (esymm σ R n) := by
intro
rw [rename_esymm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | esymm_isSymmetric | null |
support_esymm'' [DecidableEq σ] [Nontrivial R] (n : ℕ) :
(esymm σ R n).support =
(powersetCard n (univ : Finset σ)).biUnion fun t =>
(Finsupp.single (∑ i ∈ t, Finsupp.single i 1) (1 : R)).support := by
rw [esymm_eq_sum_monomial]
simp only [← single_eq_monomial]
refine Finsupp.support_sum_eq_biUnion (powersetCard n (univ : Finset σ)) ?_
intro s t hst
rw [disjoint_left, Finsupp.support_single_ne_zero _ one_ne_zero]
rw [Finsupp.support_single_ne_zero _ one_ne_zero]
simp only [mem_singleton]
rintro a h rfl
have := congr_arg Finsupp.support h
rw [Finsupp.support_sum_eq_biUnion, Finsupp.support_sum_eq_biUnion] at this
· have hsingle : ∀ s : Finset σ, ∀ x : σ, x ∈ s → (Finsupp.single x 1).support = {x} := by
intro _ x _
rw [Finsupp.support_single_ne_zero x one_ne_zero]
have hs := biUnion_congr (of_eq_true (eq_self s)) (hsingle s)
have ht := biUnion_congr (of_eq_true (eq_self t)) (hsingle t)
rw [hs, ht] at this
· simp only [biUnion_singleton_eq_self] at this
exact absurd this hst.symm
all_goals intro x y; simp [Finsupp.support_single_disjoint] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | support_esymm'' | null |
support_esymm' [DecidableEq σ] [Nontrivial R] (n : ℕ) : (esymm σ R n).support =
(powersetCard n (univ : Finset σ)).biUnion fun t => {∑ i ∈ t, Finsupp.single i 1} := by
rw [support_esymm'']
congr
funext
exact Finsupp.support_single_ne_zero _ one_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | support_esymm' | null |
support_esymm [DecidableEq σ] [Nontrivial R] (n : ℕ) : (esymm σ R n).support =
(powersetCard n (univ : Finset σ)).image fun t => ∑ i ∈ t, Finsupp.single i 1 := by
rw [support_esymm']
exact biUnion_singleton | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | support_esymm | null |
degrees_esymm [Nontrivial R] {n : ℕ} (hpos : 0 < n) (hn : n ≤ Fintype.card σ) :
(esymm σ R n).degrees = (univ : Finset σ).val := by
classical
have :
(Finsupp.toMultiset ∘ fun t : Finset σ => ∑ i ∈ t, Finsupp.single i 1) = val := by
funext
simp
rw [degrees_def, support_esymm, sup_image, this]
have : ((powersetCard n univ).sup (fun (x : Finset σ) => x)).val
= sup (powersetCard n univ) val := by
refine comp_sup_eq_sup_comp _ ?_ ?_ <;> simp
rw [← this]
obtain ⟨k, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hpos.ne'
simpa using powersetCard_sup _ _ (Nat.lt_of_succ_le hn) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | degrees_esymm | null |
hsymm (n : ℕ) : MvPolynomial σ R := ∑ s : Sym σ n, (s.1.map X).prod | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymm | The `n`th complete homogeneous symmetric `MvPolynomial σ R`.
It is the sum over all the degree n monomials in `MvPolynomial σ R`. |
hsymmPart {n : ℕ} (μ : n.Partition) : MvPolynomial σ R := (μ.parts.map (hsymm σ R)).prod
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymmPart | `hsymmPart` is the product of the symmetric polynomials `hsymm μᵢ`,
where `μ = (μ₁, μ₂, ...)` is a partition. |
hsymm_zero : hsymm σ R 0 = 1 := by simp [hsymm, eq_nil_of_card_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymm_zero | null |
hsymm_one : hsymm σ R 1 = ∑ i, X i := by
symm
apply Fintype.sum_equiv oneEquiv
simp only [oneEquiv_apply, Multiset.map_singleton, Multiset.prod_singleton, implies_true] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymm_one | null |
hsymmPart_zero : hsymmPart σ R (.indiscrete 0) = 1 := by simp [hsymmPart]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymmPart_zero | null |
hsymmPart_indiscrete (n : ℕ) : hsymmPart σ R (.indiscrete n) = hsymm σ R n := by
cases n <;> simp [hsymmPart] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymmPart_indiscrete | null |
map_hsymm (n : ℕ) (f : R →+* S) : map f (hsymm σ R n) = hsymm σ S n := by
simp [hsymm, ← Multiset.prod_hom'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | map_hsymm | null |
rename_hsymm (n : ℕ) (e : σ ≃ τ) : rename e (hsymm σ R n) = hsymm τ R n := by
simp_rw [hsymm, map_sum, ← prod_hom', rename_X]
apply Fintype.sum_equiv (equivCongr e)
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | rename_hsymm | null |
hsymm_isSymmetric (n : ℕ) : IsSymmetric (hsymm σ R n) := rename_hsymm _ _ n | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | hsymm_isSymmetric | null |
psum (n : ℕ) : MvPolynomial σ R := ∑ i, X i ^ n | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psum | The degree-`n` power sum symmetric `MvPolynomial σ R`.
It is the sum over all the `n`-th powers of the variables. |
psumPart {n : ℕ} (μ : n.Partition) : MvPolynomial σ R := (μ.parts.map (psum σ R)).prod
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psumPart | `psumPart` is the product of the symmetric polynomials `psum μᵢ`,
where `μ = (μ₁, μ₂, ...)` is a partition. |
psum_zero : psum σ R 0 = Fintype.card σ := by simp [psum]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psum_zero | null |
psum_one : psum σ R 1 = ∑ i, X i := by simp [psum]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psum_one | null |
psumPart_zero : psumPart σ R (.indiscrete 0) = 1 := by simp [psumPart]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psumPart_zero | null |
psumPart_indiscrete {n : ℕ} (npos : n ≠ 0) :
psumPart σ R (.indiscrete n) = psum σ R n := by simp [psumPart, npos]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psumPart_indiscrete | null |
rename_psum (n : ℕ) (e : σ ≃ τ) : rename e (psum σ R n) = psum τ R n := by
simp_rw [psum, map_sum, map_pow, rename_X, e.sum_comp (X · ^ n)] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | rename_psum | null |
psum_isSymmetric (n : ℕ) : IsSymmetric (psum σ R n) := rename_psum _ _ n | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | psum_isSymmetric | null |
msymm (μ : n.Partition) : MvPolynomial σ R :=
∑ s : {a : Sym σ n // .ofSym a = μ}, (s.1.1.map X).prod
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | msymm | The monomial symmetric `MvPolynomial σ R` with exponent set μ.
It is the sum over all the monomials in `MvPolynomial σ R` such that
the multiset of exponents is equal to the multiset of parts of μ. |
msymm_zero : msymm σ R (.indiscrete 0) = 1 := by
rw [msymm, Fintype.sum_subsingleton _ ⟨(Sym.nil : Sym σ 0), rfl⟩]
simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | msymm_zero | null |
msymm_one : msymm σ R (.indiscrete 1) = ∑ i, X i := by
have : (fun (x : Sym σ 1) ↦ x ∈ Set.univ) =
(fun x ↦ Nat.Partition.ofSym x = Nat.Partition.indiscrete 1) := by
simp_rw [Set.mem_univ, Nat.Partition.ofSym_one]
symm
rw [Fintype.sum_equiv (Equiv.trans Sym.oneEquiv (Equiv.Set.univ (Sym σ 1)).symm)
_ (fun s ↦ (s.1.1.map X).prod)]
· apply Fintype.sum_equiv (Equiv.subtypeEquivProp this)
intro x
congr
· intro x
rw [← Multiset.prod_singleton (X x), ← Multiset.map_singleton]
congr
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | msymm_one | null |
rename_msymm (μ : n.Partition) (e : σ ≃ τ) :
rename e (msymm σ R μ) = msymm τ R μ := by
rw [msymm, map_sum]
apply Fintype.sum_equiv (Nat.Partition.ofSymShapeEquiv μ e)
intro
rw [← Multiset.prod_hom, Multiset.map_map, Nat.Partition.ofSymShapeEquiv]
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | rename_msymm | null |
msymm_isSymmetric (μ : n.Partition) : IsSymmetric (msymm σ R μ) :=
rename_msymm _ _ μ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Combinatorics.Enumerative.Partition"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/Defs.lean | msymm_isSymmetric | null |
@[simps] accumulate (n m : ℕ) : (Fin n → ℕ) →+ (Fin m → ℕ) where
toFun t j := ∑ i : Fin n with j.val ≤ i.val, t i
map_zero' := funext <| fun _ ↦ sum_eq_zero <| fun _ _ ↦ rfl
map_add' _ _ := funext <| fun _ ↦ sum_add_distrib | def | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | accumulate | The `j`th entry of `accumulate n m t` is the sum of `t i` over all `i ≥ j`. |
invAccumulate (n m : ℕ) (s : Fin m → ℕ) (i : Fin n) : ℕ :=
(if hi : i < m then s ⟨i, hi⟩ else 0) - (if hi : i + 1 < m then s ⟨i + 1, hi⟩ else 0) | def | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | invAccumulate | The `i`th entry of `invAccumulate n m s` is `s i - s (i+1)`, where `s j = 0` if `j ≥ m`. |
accumulate_rec {i n m : ℕ} (hin : i < n) (him : i + 1 < m) (t : Fin n → ℕ) :
accumulate n m t ⟨i, Nat.lt_of_succ_lt him⟩ = t ⟨i, hin⟩ + accumulate n m t ⟨i + 1, him⟩ := by
simp_rw [accumulate_apply]
convert (add_sum_erase _ _ _).symm
· ext
rw [mem_erase]
simp_rw [mem_filter_univ, i.succ_le_iff, lt_iff_le_and_ne]
rw [and_comm, ne_comm, ← Fin.val_ne_iff]
· exact mem_filter.2 ⟨mem_univ _, le_rfl⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | accumulate_rec | null |
accumulate_last {i n m : ℕ} (hin : i < n) (hmi : m = i + 1) (t : Fin n → ℕ)
(ht : ∀ j : Fin n, m ≤ j → t j = 0) :
accumulate n m t ⟨i, i.lt_succ_self.trans_eq hmi.symm⟩ = t ⟨i, hin⟩ := by
rw [accumulate_apply]
apply sum_eq_single_of_mem
· rw [mem_filter]; exact ⟨mem_univ _, le_rfl⟩
refine fun j hij hji ↦ ht j ?_
rw [mem_filter_univ] at hij
exact hmi.trans_le (hij.lt_of_ne (Fin.val_ne_iff.2 hji).symm).nat_succ_le | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | accumulate_last | null |
accumulate_injective {n m} (hnm : n ≤ m) : Function.Injective (accumulate n m) := by
refine fun t s he ↦ funext fun i ↦ ?_
obtain h | h := lt_or_ge (i.1 + 1) m
· have := accumulate_rec i.2 h s
rwa [← he, accumulate_rec i.2 h t, add_right_cancel_iff] at this
· have := h.antisymm (i.2.nat_succ_le.trans hnm)
rw [← accumulate_last i.2 this t, ← accumulate_last i.2 this s, he]
iterate 2 { intro j hj; exact ((j.2.trans_le hnm).not_ge hj).elim } | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | accumulate_injective | null |
accumulate_invAccumulate {n m} (hmn : m ≤ n) {s : Fin m → ℕ} (hs : Antitone s) :
accumulate n m (invAccumulate n m s) = s := funext <| fun ⟨i, hi⟩ ↦ by
have := Nat.le_sub_one_of_lt hi
revert hi
refine Nat.decreasingInduction' (fun i hi _ ih him ↦ ?_) this fun hm ↦ ?_
· rw [← Nat.pred_eq_sub_one, Nat.lt_pred_iff, Nat.succ_eq_add_one] at hi
rw [accumulate_rec (him.trans_le hmn) hi, ih hi, invAccumulate, dif_pos him, dif_pos hi]
simp only
exact Nat.sub_add_cancel (hs i.le_succ)
· have := (Nat.sub_one_add_one <| Nat.ne_zero_of_lt hm).symm
rw [accumulate_last (hm.trans_le hmn) this, invAccumulate, dif_pos hm, dif_neg this.not_gt,
Nat.sub_zero]
intro j hj
rw [invAccumulate, dif_neg hj.not_gt, Nat.zero_sub] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | accumulate_invAccumulate | null |
noncomputable esymmAlgHom :
MvPolynomial (Fin n) R →ₐ[R] symmetricSubalgebra σ R :=
aeval (fun i ↦ ⟨esymm σ R (i + 1), esymm_isSymmetric σ R _⟩) | def | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom | The `R`-algebra homomorphism from $R[x_1,\dots,x_n]$ to the symmetric subalgebra of
$R[\{x_i \mid i ∈ σ\}]$ sending $x_i$ to the $i$-th elementary symmetric polynomial. |
esymmAlgHom_apply (p : MvPolynomial (Fin n) R) :
(esymmAlgHom σ R n p).val = aeval (fun i : Fin n ↦ esymm σ R (i + 1)) p :=
(Subalgebra.mvPolynomial_aeval_coe _ _ _).symm | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_apply | null |
rename_esymmAlgHom (e : σ ≃ τ) :
(renameSymmetricSubalgebra e).toAlgHom.comp (esymmAlgHom σ R n) = esymmAlgHom τ R n := by
ext i : 2
simp_rw [AlgHom.comp_apply, esymmAlgHom, aeval_X, AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_coe,
renameSymmetricSubalgebra_apply_coe, rename_esymm]
variable (σ) in | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | rename_esymmAlgHom | null |
noncomputable esymmAlgHomMonomial (t : Fin n →₀ ℕ) (r : R) :
MvPolynomial σ R := (esymmAlgHom σ R n <| monomial t r).val
variable {i : Fin n} {r : R} | def | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHomMonomial | The image of a monomial under `esymmAlgHom`. |
isSymmetric_esymmAlgHomMonomial (t : Fin n →₀ ℕ) (r : R) :
(esymmAlgHomMonomial σ t r).IsSymmetric := (esymmAlgHom _ _ _ _).2 | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | isSymmetric_esymmAlgHomMonomial | null |
esymmAlgHomMonomial_single :
esymmAlgHomMonomial σ (Finsupp.single i k) r = C r * esymm σ R (i + 1) ^ k := by
rw [esymmAlgHomMonomial, esymmAlgHom_apply, aeval_monomial, algebraMap_eq,
Finsupp.prod_single_index]
exact pow_zero _ | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHomMonomial_single | null |
esymmAlgHomMonomial_single_one :
esymmAlgHomMonomial σ (Finsupp.single i k) 1 = esymm σ R (i + 1) ^ k := by
rw [esymmAlgHomMonomial_single, map_one, one_mul] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHomMonomial_single_one | null |
esymmAlgHomMonomial_add {t s : Fin n →₀ ℕ} :
esymmAlgHomMonomial σ (t + s) r = esymmAlgHomMonomial σ t r * esymmAlgHomMonomial σ s 1 := by
simp_rw [esymmAlgHomMonomial, esymmAlgHom_apply, ← map_mul, monomial_mul, mul_one] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHomMonomial_add | null |
esymmAlgHom_zero : esymmAlgHomMonomial σ (0 : Fin n →₀ ℕ) r = C r := by
rw [esymmAlgHomMonomial, monomial_zero', esymmAlgHom_apply, aeval_C, algebraMap_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_zero | null |
private supDegree_monic_esymm [Nontrivial R] {i : ℕ} (him : i < m) :
supDegree toLex (esymm (Fin m) R (i + 1)) =
toLex (Finsupp.indicator (Iic ⟨i, him⟩) fun _ _ ↦ 1) ∧
Monic toLex (esymm (Fin m) R (i + 1)) := by
have := supDegree_leadingCoeff_sum_eq (D := toLex) (s := univ.powersetCard (i + 1))
(i := Iic (⟨i, him⟩ : Fin m)) ?_ (f := fun s ↦ monomial (∑ j ∈ s, fun₀ | j => 1) (1 : R)) ?_
· rwa [← esymm_eq_sum_monomial, ← Finsupp.indicator_eq_sum_single, ← single_eq_monomial,
supDegree_single_ne_zero _ one_ne_zero, leadingCoeff_single toLex.injective] at this
· exact mem_powersetCard.2 ⟨subset_univ _, Fin.card_Iic _⟩
intro t ht hne
have ht' : #t = #(Iic (⟨i, him⟩ : Fin m)) := by
rw [(mem_powersetCard.1 ht).2, Fin.card_Iic]
simp_rw [← single_eq_monomial, supDegree_single_ne_zero _ one_ne_zero,
← Finsupp.indicator_eq_sum_single]
rw [ne_comm, Ne, ← subset_iff_eq_of_card_le ht'.le, not_subset] at hne
simp_rw [← mem_sdiff] at hne
have hkm := mem_sdiff.1 (min'_mem _ hne)
refine ⟨min' _ hne, fun k hk ↦ ?_, ?_⟩
all_goals simp only [ofLex_toLex, Finsupp.indicator_apply]
· have hki := mem_Iic.2 (hk.le.trans <| mem_Iic.1 hkm.1)
rw [dif_pos hki, dif_pos]
by_contra h
exact lt_irrefl k <| ((lt_min'_iff _ _).1 hk) _ <| mem_sdiff.2 ⟨hki, h⟩
· rw [dif_neg hkm.2, dif_pos hkm.1]; exact Nat.zero_lt_one | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | supDegree_monic_esymm | null |
supDegree_esymm [Nontrivial R] (him : i < m) :
ofLex (supDegree toLex <| esymm (Fin m) R (i + 1)) = accumulate n m (Finsupp.single i 1) := by
rw [(supDegree_monic_esymm him).1, ofLex_toLex]
ext j
simp_rw [Finsupp.indicator_apply, dite_eq_ite, mem_Iic, accumulate_apply, Finsupp.single_apply,
sum_ite_eq, mem_filter_univ, Fin.le_def] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | supDegree_esymm | null |
monic_esymm {i : ℕ} (him : i ≤ m) : Monic toLex (esymm (Fin m) R i) := by
cases i with
| zero =>
rw [esymm_zero]
exact monic_one toLex.injective
| succ i =>
nontriviality R
exact (supDegree_monic_esymm him).2 | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | monic_esymm | null |
leadingCoeff_esymmAlgHomMonomial (t : Fin n →₀ ℕ) (hnm : n ≤ m) :
leadingCoeff toLex (esymmAlgHomMonomial (Fin m) t r) = r := by
induction t using Finsupp.induction₂ with
| zero => rw [esymmAlgHom_zero, leadingCoeff_toLex_C]
| add_single i _ _ _ _ ih =>
rw [esymmAlgHomMonomial_add, esymmAlgHomMonomial_single_one,
((monic_esymm <| i.2.trans_le hnm).pow toLex_add toLex.injective).leadingCoeff_mul_eq_left,
ih]
exacts [toLex.injective, toLex_add] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | leadingCoeff_esymmAlgHomMonomial | null |
supDegree_esymmAlgHomMonomial (hr : r ≠ 0) (t : Fin n →₀ ℕ) (hnm : n ≤ m) :
ofLex (supDegree toLex <| esymmAlgHomMonomial (Fin m) t r) = accumulate n m t := by
nontriviality R
induction t using Finsupp.induction₂ with
| zero => simp_rw [esymmAlgHom_zero, supDegree_toLex_C, ofLex_zero, Finsupp.coe_zero, map_zero]
| add_single i _ _ _ _ ih =>
have := i.2.trans_le hnm
rw [esymmAlgHomMonomial_add, esymmAlgHomMonomial_single_one,
Monic.supDegree_mul_of_ne_zero_left toLex.injective toLex_add, ofLex_add, Finsupp.coe_add,
ih, Finsupp.coe_add, map_add, Monic.supDegree_pow rfl toLex_add toLex.injective, ofLex_smul,
Finsupp.coe_smul, supDegree_esymm this, ← map_nsmul, ← Finsupp.coe_smul,
Finsupp.smul_single, nsmul_one, Nat.cast_id]
· exact monic_esymm this
· exact (monic_esymm this).pow toLex_add toLex.injective
· rwa [Ne, ← leadingCoeff_eq_zero toLex.injective, leadingCoeff_esymmAlgHomMonomial _ hnm]
omit [Fintype σ] in | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | supDegree_esymmAlgHomMonomial | null |
IsSymmetric.antitone_supDegree [LinearOrder σ] {p : MvPolynomial σ R} (hp : p.IsSymmetric) :
Antitone ↑(ofLex <| p.supDegree toLex) := by
obtain rfl | h0 := eq_or_ne p 0
· rw [supDegree_zero, Finsupp.bot_eq_zero]
exact Pi.zero_mono
rw [Antitone]
by_contra! h
obtain ⟨i, j, hle, hlt⟩ := h
apply (le_sup (s := p.support) (f := toLex) _).not_gt
pick_goal 3
· rw [← hp (Equiv.swap i j), mem_support_iff, coeff_rename_mapDomain _ (Equiv.injective _)]
rw [Ne, ← leadingCoeff_eq_zero toLex.injective, leadingCoeff_toLex] at h0
assumption
refine ⟨i, fun k hk ↦ ?_, ?_⟩
all_goals dsimp only [Pi.toLex_apply, ofLex_toLex]
· conv_rhs => rw [← Equiv.swap_apply_of_ne_of_ne hk.ne (hk.trans_le hle).ne]
rw [Finsupp.mapDomain_apply (Equiv.injective _), supDegree]; rfl
· apply hlt.trans_eq
simp_rw [Finsupp.mapDomain_equiv_apply, Equiv.symm_swap, Equiv.swap_apply_left] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | IsSymmetric.antitone_supDegree | null |
esymmAlgHom_fin_injective (h : n ≤ m) :
Function.Injective (esymmAlgHom (Fin m) R n) := by
rw [injective_iff_map_eq_zero]
refine fun p ↦ (fun hp ↦ ?_).mtr
rw [p.as_sum, map_sum (esymmAlgHom (Fin m) R n), ← Subalgebra.coe_eq_zero,
AddSubmonoidClass.coe_finset_sum]
refine sum_ne_zero_of_injOn_supDegree (D := toLex) (support_eq_empty.not.2 hp) (fun t ht ↦ ?_)
(fun t ht s hs he ↦ DFunLike.ext' <| accumulate_injective h ?_)
· rw [← esymmAlgHomMonomial, Ne, ← leadingCoeff_eq_zero toLex.injective,
leadingCoeff_esymmAlgHomMonomial t h]
rwa [mem_support_iff] at ht
rw [mem_coe, mem_support_iff] at ht hs
dsimp only [Function.comp] at he
rwa [← esymmAlgHomMonomial, ← esymmAlgHomMonomial, ← ofLex_inj, DFunLike.ext'_iff,
supDegree_esymmAlgHomMonomial ht t h, supDegree_esymmAlgHomMonomial hs s h] at he | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_fin_injective | null |
esymmAlgHom_injective (hn : n ≤ Fintype.card σ) :
Function.Injective (esymmAlgHom σ R n) := by
rw [← rename_esymmAlgHom (Fintype.equivFin σ).symm, AlgHom.coe_comp]
exact (AlgEquiv.injective _).comp (esymmAlgHom_fin_injective R hn) | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_injective | null |
esymmAlgHom_fin_bijective (n : ℕ) :
Function.Bijective (esymmAlgHom (Fin n) R n) := by
use esymmAlgHom_fin_injective R le_rfl
rintro ⟨p, hp⟩
rw [← AlgHom.mem_range]
obtain rfl | h0 := eq_or_ne p 0
· exact Subalgebra.zero_mem _
induction he : p.supDegree toLex using WellFoundedLT.induction generalizing p with | _ t ih
subst he
let t := Finsupp.equivFunOnFinite.symm (invAccumulate n n <| ↑(ofLex <| p.supDegree toLex))
have hd :
(esymmAlgHomMonomial _ t <| p.leadingCoeff toLex).supDegree toLex = p.supDegree toLex := by
rw [← ofLex_inj, DFunLike.ext'_iff, supDegree_esymmAlgHomMonomial _ _ le_rfl]
· exact accumulate_invAccumulate le_rfl hp.antitone_supDegree
· rwa [Ne, leadingCoeff_eq_zero toLex.injective]
obtain he | hne := eq_or_ne p (esymmAlgHomMonomial _ t <| p.leadingCoeff toLex)
· convert AlgHom.mem_range_self _ (monomial t <| p.leadingCoeff toLex)
have := (supDegree_sub_lt_of_leadingCoeff_eq toLex.injective hd.symm ?_).resolve_right hne
· specialize ih _ this _ (Subalgebra.sub_mem _ hp <| isSymmetric_esymmAlgHomMonomial _ _) _ rfl
· rwa [sub_ne_zero]
convert ← Subalgebra.add_mem _ ih ⟨monomial t (p.leadingCoeff toLex), rfl⟩
apply sub_add_cancel p
· rw [leadingCoeff_esymmAlgHomMonomial t le_rfl] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_fin_bijective | null |
esymmAlgHom_fin_surjective (h : m ≤ n) :
Function.Surjective (esymmAlgHom (Fin m) R n) := by
intro p
obtain ⟨q, rfl⟩ := (esymmAlgHom_fin_bijective R m).2 p
rw [← AlgHom.mem_range]
induction q using MvPolynomial.induction_on with
| C r => rw [← algebraMap_eq, AlgHom.commutes]; apply Subalgebra.algebraMap_mem
| add p q hp hq => rw [map_add]; exact Subalgebra.add_mem _ hp hq
| mul_X p i hp =>
rw [map_mul]
apply Subalgebra.mul_mem _ hp
rw [AlgHom.mem_range]
refine ⟨X ⟨i, i.2.trans_le h⟩, ?_⟩
simp_rw [esymmAlgHom, aeval_X] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_fin_surjective | null |
esymmAlgHom_surjective (hn : Fintype.card σ ≤ n) :
Function.Surjective (esymmAlgHom σ R n) := by
rw [← rename_esymmAlgHom (Fintype.equivFin σ).symm, AlgHom.coe_comp]
exact (AlgEquiv.surjective _).comp (esymmAlgHom_fin_surjective R hn)
variable (σ) in | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgHom_surjective | null |
@[simps! apply]
noncomputable esymmAlgEquiv (hn : Fintype.card σ = n) :
MvPolynomial (Fin n) R ≃ₐ[R] symmetricSubalgebra σ R :=
AlgEquiv.ofBijective (esymmAlgHom σ R n)
⟨esymmAlgHom_injective R hn.ge, esymmAlgHom_surjective R hn.le⟩ | def | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgEquiv | If the cardinality of `σ` is `n`, then `esymmAlgHom σ R n` is an isomorphism. |
esymmAlgEquiv_symm_apply (hn : Fintype.card σ = n) (i : Fin n) :
(esymmAlgEquiv σ R hn).symm ⟨esymm σ R (i + 1), esymm_isSymmetric σ R _⟩ = X i := by
apply_fun esymmAlgHom σ R n using esymmAlgHom_injective R hn.ge
simp_rw [esymmAlgEquiv, AlgEquiv.ofBijective_apply_symm_apply, esymmAlgHom, aeval_X] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.Data.Finsupp.Notation",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean | esymmAlgEquiv_symm_apply | null |
private pairMap (t : Finset σ × σ) : Finset σ × σ :=
if h : t.snd ∈ t.fst then (t.fst.erase t.snd, t.snd) else (t.fst.cons t.snd h, t.snd) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap | null |
private pairMap_ne_self (t : Finset σ × σ) : pairMap σ t ≠ t := by
rw [pairMap]
split_ifs with h1
all_goals by_contra ht; rw [← ht] at h1; simp_all | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap_ne_self | null |
private pairMap_of_snd_mem_fst {t : Finset σ × σ} (h : t.snd ∈ t.fst) :
pairMap σ t = (t.fst.erase t.snd, t.snd) := by
simp [pairMap, h] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap_of_snd_mem_fst | null |
private pairMap_of_snd_notMem_fst {t : Finset σ × σ} (h : t.snd ∉ t.fst) :
pairMap σ t = (t.fst.cons t.snd h, t.snd) := by
simp [pairMap, h]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap_of_snd_notMem_fst | null |
private pairMap_involutive : (pairMap σ).Involutive := by
intro t
rw [pairMap, pairMap]
split_ifs with h1 h2 h3
· simp at h2
· simp [insert_erase h1]
· simp_all
· simp at h3
variable [Fintype σ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap_involutive | null |
private pairs (k : ℕ) : Finset (Finset σ × σ) :=
{t | #t.1 ≤ k ∧ (#t.1 = k → t.snd ∈ t.fst)}
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairs | null |
private mem_pairs (k : ℕ) (t : Finset σ × σ) :
t ∈ pairs σ k ↔ #t.1 ≤ k ∧ (#t.1 = k → t.snd ∈ t.fst) := by
simp [pairs] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | mem_pairs | null |
private weight (k : ℕ) (t : Finset σ × σ) : MvPolynomial σ R :=
(-1) ^ #t.1 * ((∏ a ∈ t.fst, X a) * X t.snd ^ (k - #t.1)) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | weight | null |
private pairMap_mem_pairs {k : ℕ} (t : Finset σ × σ) (h : t ∈ pairs σ k) :
pairMap σ t ∈ pairs σ k := by
rw [mem_pairs] at h ⊢
rcases (em (t.snd ∈ t.fst)) with h1 | h1
· rw [pairMap_of_snd_mem_fst σ h1]
simp only [h1, implies_true, and_true] at h
simp only [card_erase_of_mem h1, tsub_le_iff_right, mem_erase, ne_eq, h1]
refine ⟨le_step h, ?_⟩
by_contra h2
simp only [not_true_eq_false, and_true, not_forall, not_false_eq_true, exists_prop] at h2
rw [← h2] at h
exact not_le_of_gt (sub_lt (card_pos.mpr ⟨t.snd, h1⟩) zero_lt_one) h
· rw [pairMap_of_snd_notMem_fst σ h1]
simp only [h1] at h
simp only [card_cons, mem_cons, true_or, implies_true, and_true]
exact (le_iff_eq_or_lt.mp h.left).resolve_left h.right | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | pairMap_mem_pairs | null |
private weight_add_weight_pairMap {k : ℕ} (t : Finset σ × σ) (h : t ∈ pairs σ k) :
weight σ R k t + weight σ R k (pairMap σ t) = 0 := by
rw [weight, weight]
rw [mem_pairs] at h
have h2 (n : ℕ) : -(-1 : MvPolynomial σ R) ^ n = (-1) ^ (n + 1) := by
rw [← neg_one_mul ((-1 : MvPolynomial σ R) ^ n), pow_add, pow_one, mul_comm]
rcases (em (t.snd ∈ t.fst)) with h1 | h1
· rw [pairMap_of_snd_mem_fst σ h1]
simp only [← prod_erase_mul t.fst (fun j ↦ (X j : MvPolynomial σ R)) h1,
mul_assoc (∏ a ∈ erase t.fst t.snd, X a), card_erase_of_mem h1]
nth_rewrite 1 [← pow_one (X t.snd)]
simp only [← pow_add, add_comm]
have h3 : 1 ≤ #t.1 := lt_iff_add_one_le.mp (card_pos.mpr ⟨t.snd, h1⟩)
rw [← tsub_tsub_assoc h.left h3, ← neg_neg ((-1 : MvPolynomial σ R) ^ (#t.1 - 1)),
h2 (#t.1 - 1), Nat.sub_add_cancel h3]
simp
· rw [pairMap_of_snd_notMem_fst σ h1]
simp only [mul_comm, mul_assoc (∏ a ∈ t.fst, X a), card_cons, prod_cons]
nth_rewrite 2 [← pow_one (X t.snd)]
simp only [← pow_add, ← Nat.add_sub_assoc (Nat.lt_of_le_of_ne h.left (mt h.right h1)), add_comm,
Nat.succ_eq_add_one, Nat.add_sub_add_right]
rw [← neg_neg ((-1 : MvPolynomial σ R) ^ #t.1), h2]
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | weight_add_weight_pairMap | null |
private weight_sum (k : ℕ) : ∑ t ∈ pairs σ k, weight σ R k t = 0 :=
sum_involution (fun t _ ↦ pairMap σ t) (weight_add_weight_pairMap σ R)
(fun t _ ↦ (fun _ ↦ pairMap_ne_self σ t)) (pairMap_mem_pairs σ)
(fun t _ ↦ pairMap_involutive σ t) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Rename",
"Mathlib.Data.Fintype.Basic",
"Mathlib.RingTheory.MvPolynomial.Symmetric.Defs"
] | Mathlib/RingTheory/MvPolynomial/Symmetric/NewtonIdentities.lean | weight_sum | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.