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 ⌀ |
|---|---|---|---|---|---|---|
hasSubst_iff_hasEval_of_discreteTopology [TopologicalSpace S] [DiscreteTopology S] :
HasSubst a ↔ HasEval a := by
simp_rw [hasSubst_def, hasEval_def, coeff_zero_iff,
isTopologicallyNilpotent_iff_constantCoeff_isNilpotent] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | hasSubst_iff_hasEval_of_discreteTopology | A multivariate power series can be substituted if and only if
it can be evaluated when the topology on the coefficients ring is the discrete topology. |
HasSubst.hasEval [TopologicalSpace S] (ha : HasSubst a) :
HasEval a := HasEval.mono (instTopologicalSpace_mono τ bot_le) <|
(@hasSubst_iff_hasEval_of_discreteTopology σ τ _ _ a ⊥ (@DiscreteTopology.mk S ⊥ rfl)).mp ha | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.hasEval | null |
HasSubst.zero : HasSubst (fun (_ : σ) ↦ (0 : MvPowerSeries τ S)) := by
letI : UniformSpace S := ⊥
simpa [hasSubst_iff_hasEval_of_discreteTopology] using HasEval.zero | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.zero | null |
HasSubst.add {a b : σ → MvPowerSeries τ S} (ha : HasSubst a) (hb : HasSubst b) :
HasSubst (a + b) := by
letI : UniformSpace S := ⊥
rw [hasSubst_iff_hasEval_of_discreteTopology] at ha hb ⊢
exact ha.add hb | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.add | null |
HasSubst.mul_left (b : σ → MvPowerSeries τ S)
{a : σ → MvPowerSeries τ S} (ha : HasSubst a) :
HasSubst (b * a) := by
letI : UniformSpace S := ⊥
rw [hasSubst_iff_hasEval_of_discreteTopology] at ha ⊢
exact ha.mul_left b | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.mul_left | null |
HasSubst.mul_right (b : σ → MvPowerSeries τ S)
{a : σ → MvPowerSeries τ S} (ha : HasSubst a) :
HasSubst (a * b) :=
mul_comm a b ▸ ha.mul_left b | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.mul_right | null |
HasSubst.smul (r : MvPowerSeries τ S) {a : σ → MvPowerSeries τ S} (ha : HasSubst a) :
HasSubst (r • a) := ha.mul_left _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.smul | null |
protected HasSubst.X : HasSubst (fun (s : σ) ↦ (X s : MvPowerSeries σ S)) := by
letI : UniformSpace S := ⊥
simpa [hasSubst_iff_hasEval_of_discreteTopology] using HasEval.X | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.X | null |
HasSubst.smul_X (a : σ → R) :
HasSubst (a • X : σ → MvPowerSeries σ R) := by
convert HasSubst.X.mul_left (fun s ↦ algebraMap R (MvPowerSeries σ R) (a s))
simp [funext_iff, algebra_compatible_smul (MvPowerSeries σ R)] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.smul_X | null |
noncomputable hasSubstIdeal : Ideal (σ → MvPowerSeries τ S) :=
{ carrier := setOf HasSubst
add_mem' := HasSubst.add
zero_mem' := HasSubst.zero
smul_mem' := HasSubst.mul_left } | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | hasSubstIdeal | Families of `MvPowerSeries` that can be substituted, as an `Ideal` |
hasSubst_of_constantCoeff_nilpotent [Finite σ]
{a : σ → MvPowerSeries τ S} (ha : ∀ s, IsNilpotent (constantCoeff (a s))) :
HasSubst a where
const_coeff := ha
coeff_zero _ := Set.toFinite _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | hasSubst_of_constantCoeff_nilpotent | If `σ` is finite, then the nilpotent condition is enough for `HasSubst` |
hasSubst_of_constantCoeff_zero [Finite σ]
{a : σ → MvPowerSeries τ S} (ha : ∀ s, constantCoeff (a s) = 0) :
HasSubst a :=
hasSubst_of_constantCoeff_nilpotent (fun s ↦ by simp only [ha s, IsNilpotent.zero]) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | hasSubst_of_constantCoeff_zero | If `σ` is finite, then having zero constant coefficient is enough for `HasSubst` |
noncomputable subst (a : σ → MvPowerSeries τ S) (f : MvPowerSeries σ R) :
MvPowerSeries τ S :=
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
eval₂ (algebraMap _ _) a f | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst | Substitution of power series into a power series
It coincides with evaluation when `f` is a polynomial, or under `HasSubst a`.
Otherwise, it is given the dummy value `0`. |
subst_eq_eval₂
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S] :
(subst : (σ → MvPowerSeries τ S) → (MvPowerSeries σ R) → _) = eval₂ (algebraMap _ _) := by
ext; simp [subst, DiscreteUniformity.eq_bot] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_eq_eval₂ | null |
subst_coe (p : MvPolynomial σ R) :
subst (R := R) a p = MvPolynomial.aeval a p := by
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
rw [subst_eq_eval₂, eval₂_coe, MvPolynomial.aeval_def]
variable {a : σ → MvPowerSeries τ S} | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_coe | null |
noncomputable substAlgHom (ha : HasSubst a) :
MvPowerSeries σ R →ₐ[R] MvPowerSeries τ S :=
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
MvPowerSeries.aeval ha.hasEval | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom | For `HasSubst a`, `MvPowerSeries.subst` is an algebra morphism. |
substAlgHom_eq_aeval
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) :
(substAlgHom ha : MvPowerSeries σ R → MvPowerSeries τ S) = MvPowerSeries.aeval ha.hasEval := by
simp only [substAlgHom, coe_aeval ha.hasEval]
convert coe_aeval (R := R) (hasSubst_iff_hasEval_of_discreteTopology.mp ha) <;>
exact DiscreteUniformity.eq_bot.symm
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_eq_aeval | Rewrite `MvPowerSeries.substAlgHom` as `MvPowerSeries.aeval`.
Its use is discouraged because it introduces a topology and might lead
into awkward comparisons. |
coe_substAlgHom (ha : HasSubst a) :
⇑(substAlgHom ha) = subst (R := R) a := by
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
rw [substAlgHom_eq_aeval, coe_aeval ha.hasEval, subst_eq_eval₂] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | coe_substAlgHom | null |
subst_self : subst (MvPowerSeries.X : σ → MvPowerSeries σ R) = id := by
rw [← coe_substAlgHom HasSubst.X]
letI : UniformSpace R := ⊥
ext1 f
simp only [substAlgHom_eq_aeval]
have := aeval_unique (ε := AlgHom.id R (MvPowerSeries σ R)) continuous_id
rw [DFunLike.ext_iff] at this
exact this f
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_self | null |
substAlgHom_apply (ha : HasSubst a) (f : MvPowerSeries σ R) :
substAlgHom ha f = subst a f := by
rw [coe_substAlgHom] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_apply | null |
subst_add (ha : HasSubst a) (f g : MvPowerSeries σ R) :
subst a (f + g) = subst a f + subst a g := by
simp only [← substAlgHom_apply ha, map_add] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_add | null |
subst_mul (ha : HasSubst a) (f g : MvPowerSeries σ R) :
subst a (f * g) = subst a f * subst a g := by
simp only [← substAlgHom_apply ha, map_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_mul | null |
subst_pow (ha : HasSubst a) (f : MvPowerSeries σ R) (n : ℕ) :
subst a (f ^ n) = (subst a f) ^ n := by
simp only [← substAlgHom_apply ha, map_pow] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_pow | null |
subst_smul (ha : HasSubst a) (r : A) (f : MvPowerSeries σ R) :
subst a (r • f) = r • (subst a f) := by
simp only [← substAlgHom_apply ha, AlgHom.map_smul_of_tower] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_smul | null |
substAlgHom_coe (ha : HasSubst a) (p : MvPolynomial σ R) :
substAlgHom (R := R) ha p = MvPolynomial.aeval a p := by
simp [substAlgHom] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_coe | null |
substAlgHom_X (ha : HasSubst a) (s : σ) :
substAlgHom (R := R) ha (X s) = a s := by
rw [← MvPolynomial.coe_X, substAlgHom_coe ha, MvPolynomial.aeval_X] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_X | null |
substAlgHom_monomial (ha : HasSubst a) (e : σ →₀ ℕ) (r : R) :
substAlgHom ha (monomial e r) =
(algebraMap R (MvPowerSeries τ S) r) * (e.prod (fun s n ↦ (a s) ^ n)) := by
rw [← MvPolynomial.coe_monomial, substAlgHom_coe, MvPolynomial.aeval_monomial]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_monomial | null |
subst_X (ha : HasSubst a) (s : σ) :
subst (R := R) a (X s) = a s := by
rw [← coe_substAlgHom ha, substAlgHom_X] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_X | null |
subst_monomial (ha : HasSubst a) (e : σ →₀ ℕ) (r : R) :
subst a (monomial e r) =
(algebraMap R (MvPowerSeries τ S) r) * (e.prod (fun s n ↦ (a s) ^ n)) := by
rw [← coe_substAlgHom ha, substAlgHom_monomial] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_monomial | null |
continuous_subst (ha : HasSubst a)
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S] :
Continuous (subst a : MvPowerSeries σ R → MvPowerSeries τ S) := by
rw [subst_eq_eval₂]
exact continuous_eval₂ (continuous_algebraMap _ _) ha.hasEval | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | continuous_subst | null |
coeff_subst_finite (ha : HasSubst a) (f : MvPowerSeries σ R) (e : τ →₀ ℕ) :
Set.Finite (fun d ↦ coeff d f • (coeff e (d.prod fun s e => (a s) ^ e))).support :=
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
Summable.finite_support_of_discreteTopology _
((hasSum_aeval ha.hasEval f).map (coeff e) (continuous_coeff S e)).summable | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | coeff_subst_finite | null |
coeff_subst (ha : HasSubst a) (f : MvPowerSeries σ R) (e : τ →₀ ℕ) :
coeff e (subst a f) =
finsum (fun d ↦ coeff d f • (coeff e (d.prod fun s e => (a s) ^ e))) := by
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
have := ((hasSum_aeval ha.hasEval f).map (coeff e) (continuous_coeff S e))
rw [← coe_substAlgHom ha, substAlgHom, ← this.tsum_eq, tsum_def, dif_pos this.summable]
exact if_pos (coeff_subst_finite ha f e) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | coeff_subst | null |
constantCoeff_subst (ha : HasSubst a) (f : MvPowerSeries σ R) :
constantCoeff (subst a f) =
finsum (fun d ↦ coeff d f • (constantCoeff (d.prod fun s e => (a s) ^ e))) := by
simp only [← coeff_zero_eq_constantCoeff_apply, coeff_subst ha f 0] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | constantCoeff_subst | null |
map_algebraMap_eq_subst_X (f : MvPowerSeries σ R) :
map (algebraMap R S) f = subst X f := by
ext e
rw [coeff_map, coeff_subst HasSubst.X f e, finsum_eq_single _ e]
· rw [← MvPowerSeries.monomial_one_eq, coeff_monomial_same,
algebra_compatible_smul S, smul_eq_mul, mul_one]
· intro d hd
rw [← MvPowerSeries.monomial_one_eq, coeff_monomial_ne hd.symm, smul_zero]
variable
{T : Type*} [CommRing T]
[UniformSpace T] [T2Space T] [CompleteSpace T]
[IsUniformAddGroup T] [IsTopologicalRing T] [IsLinearTopology T T] [Algebra R T]
{ε : MvPowerSeries τ S →ₐ[R] T} | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | map_algebraMap_eq_subst_X | null |
comp_substAlgHom
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) (hε : Continuous ε) :
ε.comp (substAlgHom ha) = aeval (ha.hasEval.map hε) := by
ext f
simp only [AlgHom.coe_comp, substAlgHom_eq_aeval ha]
exact DFunLike.congr_fun (comp_aeval ha.hasEval hε) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | comp_substAlgHom | null |
comp_subst [UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) (hε : Continuous ε) :
ε ∘ (subst a) = aeval (R := R) (ha.hasEval.map hε) := by
rw [← comp_substAlgHom ha hε, AlgHom.coe_comp, coe_substAlgHom] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | comp_subst | null |
comp_subst_apply
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) (hε : Continuous ε) (f : MvPowerSeries σ R) :
ε (subst a f) = aeval (R := R) (ha.hasEval.map hε) f :=
congr_fun (comp_subst ha hε) f
variable [Algebra S T] [IsScalarTower R S T] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | comp_subst_apply | null |
eval₂_subst
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) {b : τ → T} (hb : HasEval b) (f : MvPowerSeries σ R) :
eval₂ (algebraMap S T) b (subst a f) =
eval₂ (algebraMap R T) (fun s ↦ eval₂ (algebraMap S T) b (a s)) f := by
let ε : MvPowerSeries τ S →ₐ[R] T := (aeval hb).restrictScalars R
have hε : Continuous ε := continuous_aeval hb
simpa only [AlgHom.coe_restrictScalars', AlgHom.toRingHom_eq_coe,
AlgHom.coe_restrictScalars, RingHom.coe_coe, ε, coe_aeval]
using comp_subst_apply ha hε f
variable {υ : Type*}
{T : Type*} [CommRing T] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
{b : τ → MvPowerSeries υ T} | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | eval₂_subst | null |
IsNilpotent_subst (ha : HasSubst a)
{f : MvPowerSeries σ R} (hf : IsNilpotent (constantCoeff f)) :
IsNilpotent (constantCoeff (substAlgHom ha f)) := by
classical
rw [coe_substAlgHom, constantCoeff_subst ha]
apply isNilpotent_finsum
intro d
by_cases hd : d = 0
· rw [← algebraMap_smul S, smul_eq_mul, mul_comm, ← smul_eq_mul, hd]
apply IsNilpotent.smul
simpa using IsNilpotent.map hf (algebraMap R S)
· apply IsNilpotent.smul
rw [← ne_eq, Finsupp.ne_iff] at hd
obtain ⟨t, hs⟩ := hd
rw [← Finsupp.prod_filter_mul_prod_filter_not (fun i ↦ i = t), map_mul,
mul_comm, ← smul_eq_mul]
apply IsNilpotent.smul
rw [Finsupp.prod_eq_single t]
· simpa using IsNilpotent.pow_of_pos (ha.const_coeff t) hs
· intro t' htt' ht'
simp [ht'] at htt'
· exact fun _ ↦ by rw [pow_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | IsNilpotent_subst | null |
HasSubst.comp (ha : HasSubst a) (hb : HasSubst b) :
HasSubst (fun s ↦ substAlgHom hb (a s)) where
const_coeff s := IsNilpotent_subst hb (ha.const_coeff s)
coeff_zero := by
letI : UniformSpace S := ⊥
letI : UniformSpace T := ⊥
rw [← coeff_zero_iff]
apply Filter.Tendsto.comp _ (ha.hasEval.tendsto_zero)
simpa [← map_zero (substAlgHom (R := S) hb)] using (continuous_subst hb).continuousAt | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst.comp | null |
substAlgHom_comp_substAlgHom (ha : HasSubst a) (hb : HasSubst b) :
((substAlgHom hb).restrictScalars R).comp (substAlgHom ha) = substAlgHom (ha.comp hb) := by
letI : UniformSpace R := ⊥
letI : UniformSpace S := ⊥
letI : UniformSpace T := ⊥
apply comp_aeval (R := R) (ε := (substAlgHom hb).restrictScalars R) ha.hasEval
simpa [AlgHom.coe_restrictScalars'] using continuous_subst (R := S) hb | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_comp_substAlgHom | null |
substAlgHom_comp_substAlgHom_apply (ha : HasSubst a) (hb : HasSubst b)
(f : MvPowerSeries σ R) :
(substAlgHom hb) (substAlgHom ha f) = substAlgHom (ha.comp hb) f :=
DFunLike.congr_fun (substAlgHom_comp_substAlgHom ha hb) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | substAlgHom_comp_substAlgHom_apply | null |
subst_comp_subst (ha : HasSubst a) (hb : HasSubst b) :
(subst b) ∘ (subst a) = subst (R := R) (fun s ↦ subst b (a s)) := by
simpa [funext_iff, DFunLike.ext_iff] using substAlgHom_comp_substAlgHom (R := R) ha hb | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_comp_subst | null |
subst_comp_subst_apply (ha : HasSubst a) (hb : HasSubst b) (f : MvPowerSeries σ R) :
subst b (subst a f) = subst (fun s ↦ subst b (a s)) f :=
congr_fun (subst_comp_subst (R := R) ha hb) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | subst_comp_subst_apply | null |
noncomputable rescale (a : σ → R) : MvPowerSeries σ R →+* MvPowerSeries σ R where
toFun f := fun n ↦ (n.prod fun s m ↦ a s ^ m) * f.coeff n
map_zero' := by
ext
simp [map_zero, coeff_apply]
map_one' := by
ext1 n
classical
simp only [coeff_one, mul_ite, mul_one, mul_zero]
split_ifs with h
· simp [h, coeff_apply]
· simp only [coeff_apply, ite_eq_right_iff]
exact fun a_1 ↦ False.elim (h a_1)
map_add' := by
intros
ext
exact mul_add _ _ _
map_mul' f g := by
ext n
classical
rw [coeff_apply, coeff_mul, coeff_mul, Finset.mul_sum]
apply Finset.sum_congr rfl
intro x hx
simp only [Finset.mem_antidiagonal] at hx
rw [← hx]
simp only [coeff_apply]
rw [Finsupp.prod_of_support_subset _ Finsupp.support_add,
Finsupp.prod_of_support_subset x.1 Finset.subset_union_left,
Finsupp.prod_of_support_subset x.2 Finset.subset_union_right]
· simp only [← mul_assoc]
congr 1
rw [mul_assoc, mul_comm (f x.1), ← mul_assoc]
congr 1
rw [← Finset.prod_mul_distrib]
apply Finset.prod_congr rfl
simp [pow_add]
all_goals {simp}
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale | The ring homomorphism taking a multivariate power series `f(X)` to `f(aX)`. |
coeff_rescale (f : MvPowerSeries σ R) (a : σ → R) (n : σ →₀ ℕ) :
coeff n (rescale a f) = (n.prod fun s m ↦ a s ^ m) * f.coeff n := by
simp [rescale, coeff_apply]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | coeff_rescale | null |
rescale_zero :
(rescale 0 : MvPowerSeries σ R →+* MvPowerSeries σ R) = C.comp constantCoeff := by
classical
ext x n
simp [Function.comp_apply, RingHom.coe_comp, rescale, RingHom.coe_mk, coeff_C]
split_ifs with h
· simp [h, coeff_apply, ← @coeff_zero_eq_constantCoeff_apply, coeff_apply]
· simp only [coeff_apply]
convert zero_mul _
simp only [DFunLike.ext_iff, not_forall, Finsupp.coe_zero, Pi.zero_apply] at h
obtain ⟨s, h⟩ := h
simp only [Finsupp.prod]
apply Finset.prod_eq_zero (i := s) _ (zero_pow h)
simpa using h | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_zero | null |
rescale_zero_apply (f : MvPowerSeries σ R) :
rescale 0 f = C (constantCoeff f) := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_zero_apply | null |
rescale_one : rescale 1 = RingHom.id (MvPowerSeries σ R) := by
ext f n
simp [coeff_rescale, Finsupp.prod] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_one | null |
rescale_rescale (f : MvPowerSeries σ R) (a b : σ → R) :
rescale b (rescale a f) = rescale (a * b) f := by
ext n
simp [← mul_assoc, mul_pow, mul_comm] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_rescale | null |
rescale_mul (a b : σ → R) : rescale (a * b) = (rescale b).comp (rescale a) := by
ext
simp [← rescale_rescale] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_mul | null |
rescale_homogeneous_eq_smul {n : ℕ} {r : R} {f : MvPowerSeries σ R}
(hf : ∀ d ∈ f.support, d.degree = n) :
MvPowerSeries.rescale (Function.const σ r) f = r ^ n • f := by
ext e
simp only [MvPowerSeries.coeff_rescale, map_smul, Finsupp.prod, Function.const_apply,
Finset.prod_pow_eq_pow_sum, smul_eq_mul]
by_cases he : e ∈ f.support
· rw [← hf e he, Finsupp.degree]
· simp only [Function.mem_support, ne_eq, not_not] at he
simp [he, mul_zero, coeff_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_homogeneous_eq_smul | Rescaling a homogeneous power series |
noncomputable rescaleMonoidHom :
(σ → R) →* MvPowerSeries σ R →+* MvPowerSeries σ R where
toFun := rescale
map_one' := rescale_one
map_mul' a b := by ext; simp [mul_comm, rescale_rescale] | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescaleMonoidHom | Rescale a multivariate power series, as a `MonoidHom` in the scaling parameters. |
rescale_eq_subst (a : σ → R) (f : MvPowerSeries σ R) :
rescale a f = subst (a • X) f := by
classical
ext n
rw [coeff_rescale]
rw [coeff_subst (HasSubst.smul_X a),
finsum_eq_sum _ (coeff_subst_finite (HasSubst.smul_X a) f n)]
simp only [Pi.smul_apply', smul_eq_mul]
rw [Finset.sum_eq_single n _ _]
· simp [mul_comm, ← monomial_eq]
· intro b hb hbn
rw [← monomial_eq, coeff_monomial, if_neg (Ne.symm hbn), mul_zero]
· intro hn
simpa using hn | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescale_eq_subst | null |
noncomputable rescaleAlgHom (a : σ → R) :
MvPowerSeries σ R →ₐ[R] MvPowerSeries σ R :=
substAlgHom (HasSubst.smul_X a) | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescaleAlgHom | Rescale a multivariate power series, as an `AlgHom` in the scaling parameters,
by multiplying each variable `x` by the value `a x`. |
rescaleAlgHom_apply (a : σ → R) (f : MvPowerSeries σ R) :
rescaleAlgHom a f = rescale a f := by
simp [rescaleAlgHom, rescale_eq_subst] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescaleAlgHom_apply | null |
rescaleAlgHom_mul (a b : σ → R) :
rescaleAlgHom (a * b) = (rescaleAlgHom b).comp (rescaleAlgHom a) := by
ext1 f
simp [rescaleAlgHom_apply, rescale_rescale] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescaleAlgHom_mul | null |
rescaleAlgHom_one :
rescaleAlgHom 1 = AlgHom.id R (MvPowerSeries σ R) := by
ext1 f
simp [rescaleAlgHom, subst_self] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | rescaleAlgHom_one | null |
truncFun (φ : MvPowerSeries σ R) : MvPolynomial σ R :=
∑ m ∈ Finset.Iio n, MvPolynomial.monomial m (coeff m φ) | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | truncFun | Auxiliary definition for the truncation function. |
coeff_truncFun (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
(truncFun n φ).coeff m = if m < n then coeff m φ else 0 := by
classical
simp [truncFun, MvPolynomial.coeff_sum]
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | coeff_truncFun | null |
trunc : MvPowerSeries σ R →+ MvPolynomial σ R where
toFun := truncFun n
map_zero' := by
classical
ext
simp [coeff_truncFun]
map_add' := by
classical
intro x y
ext m
simp only [coeff_truncFun, MvPolynomial.coeff_add, ite_add_ite, ← map_add, add_zero] | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc | The `n`th truncation of a multivariate formal power series to a multivariate polynomial
If `f : MvPowerSeries σ R` and `n : σ →₀ ℕ` is a (finitely-supported) function from `σ`
to the naturals, then `trunc' R n f` is the multivariable power series obtained from `f`
by keeping only the monomials $c\prod_i X_i^{a_i}$ where `a i ≤ n i` for all `i`
and $a i < n i` for some `i`. |
coeff_trunc (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
(trunc R n φ).coeff m = if m < n then coeff m φ else 0 := by
classical simp [trunc, coeff_truncFun]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | coeff_trunc | null |
trunc_one (n : σ →₀ ℕ) (hnn : n ≠ 0) : trunc R n 1 = 1 :=
MvPolynomial.ext _ _ fun m ↦ by
classical
rw [coeff_trunc, coeff_one]
split_ifs with H H'
· subst m
simp
· symm
rw [MvPolynomial.coeff_one]
exact if_neg (Ne.symm H')
· symm
rw [MvPolynomial.coeff_one]
refine if_neg ?_
rintro rfl
apply H
exact Ne.bot_lt hnn
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc_one | null |
trunc_C (n : σ →₀ ℕ) (hnn : n ≠ 0) (a : R) : trunc R n (C a) = MvPolynomial.C a :=
MvPolynomial.ext _ _ fun m ↦ by
classical
rw [coeff_trunc, coeff_C, MvPolynomial.coeff_C]
split_ifs with H <;> first | rfl | try simp_all only [ne_eq, not_true_eq_false]
exfalso; apply H; subst m; exact Ne.bot_lt hnn
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc_C | null |
trunc_C_mul (n : σ →₀ ℕ) (a : R) (p : MvPowerSeries σ R) :
trunc R n (C a * p) = MvPolynomial.C a * trunc R n p := by
ext m; simp [coeff_trunc]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc_C_mul | null |
trunc_map [CommSemiring S] (n : σ →₀ ℕ) (f : R →+* S) (p : MvPowerSeries σ R) :
trunc S n (map f p) = MvPolynomial.map f (trunc R n p) := by
ext m; simp [coeff_trunc, MvPolynomial.coeff_map, apply_ite f] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc_map | null |
truncFun' (φ : MvPowerSeries σ R) : MvPolynomial σ R :=
∑ m ∈ Finset.Iic n, MvPolynomial.monomial m (coeff m φ) | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | truncFun' | Auxiliary definition for the truncation function. |
coeff_truncFun' (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
(truncFun' n φ).coeff m = if m ≤ n then coeff m φ else 0 := by
classical
simp [truncFun', MvPolynomial.coeff_sum]
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | coeff_truncFun' | Coefficients of the truncated function. |
trunc' : MvPowerSeries σ R →+ MvPolynomial σ R where
toFun := truncFun' n
map_zero' := by
ext
simp only [coeff_truncFun', map_zero, ite_self, MvPolynomial.coeff_zero]
map_add' x y := by
ext m
simp only [coeff_truncFun', MvPolynomial.coeff_add]
rw [ite_add_ite, ← map_add, zero_add] | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc' | The `n`th truncation of a multivariate formal power series to a multivariate polynomial.
If `f : MvPowerSeries σ R` and `n : σ →₀ ℕ` is a (finitely-supported) function from `σ`
to the naturals, then `trunc' R n f` is the multivariable power series obtained from `f`
by keeping only the monomials $c\prod_i X_i^{a_i}$ where `a i ≤ n i` for all `i`. |
coeff_trunc' (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
(trunc' R n φ).coeff m = if m ≤ n then coeff m φ else 0 :=
coeff_truncFun' n m φ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | coeff_trunc' | Coefficients of the truncation of a multivariate power series. |
@[simp]
trunc'_one (n : σ →₀ ℕ) : trunc' R n 1 = 1 :=
MvPolynomial.ext _ _ fun m ↦ by
classical
rw [coeff_trunc', coeff_one]
split_ifs with H H'
· subst m; simp only [MvPolynomial.coeff_zero_one]
· rw [MvPolynomial.coeff_one, if_neg (Ne.symm H')]
· rw [MvPolynomial.coeff_one, if_neg ?_]
rintro rfl
exact H (zero_le n)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc'_one | Truncation of the multivariate power series `1` |
trunc'_C (n : σ →₀ ℕ) (a : R) :
trunc' R n (C a) = MvPolynomial.C a :=
MvPolynomial.ext _ _ fun m ↦ by
classical
rw [coeff_trunc', coeff_C, MvPolynomial.coeff_C]
split_ifs with H <;> first | rfl | try simp_all
exfalso; apply H; subst m; exact zero_le n | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc'_C | null |
coeff_mul_eq_coeff_trunc'_mul_trunc' (n : σ →₀ ℕ)
(f g : MvPowerSeries σ R) {m : σ →₀ ℕ} (h : m ≤ n) :
coeff m (f * g) = (trunc' R n f * trunc' R n g).coeff m := by
classical
simp only [MvPowerSeries.coeff_mul, MvPolynomial.coeff_mul]
apply Finset.sum_congr rfl
rintro ⟨i, j⟩ hij
simp only [mem_antidiagonal] at hij
rw [← hij] at h
simp only
apply congr_arg₂
· rw [coeff_trunc', if_pos (le_trans le_self_add h)]
· rw [coeff_trunc', if_pos (le_trans le_add_self h)]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | coeff_mul_eq_coeff_trunc'_mul_trunc' | Coefficients of the truncation of a product of two multivariate power series |
trunc'_C_mul (n : σ →₀ ℕ) (a : R) (p : MvPowerSeries σ R) :
trunc' R n (C a * p) = MvPolynomial.C a * trunc' R n p := by
ext m; simp [coeff_trunc']
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc'_C_mul | null |
trunc'_map [CommSemiring S] (n : σ →₀ ℕ) (f : R →+* S) (p : MvPowerSeries σ R) :
trunc' S n (map f p) = MvPolynomial.map f (trunc' R n p) := by
ext m; simp [coeff_trunc', MvPolynomial.coeff_map, apply_ite f] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.Interval",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Trunc.lean | trunc'_map | null |
IsNilpotent.neg [Ring R] (h : IsNilpotent x) : IsNilpotent (-x) := by
obtain ⟨n, hn⟩ := h
use n
rw [neg_pow, hn, mul_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.neg | null |
isNilpotent_neg_iff [Ring R] : IsNilpotent (-x) ↔ IsNilpotent x :=
⟨fun h => neg_neg x ▸ h.neg, fun h => h.neg⟩ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_neg_iff | null |
IsNilpotent.smul [MonoidWithZero R] [MonoidWithZero S] [MulActionWithZero R S]
[SMulCommClass R S S] [IsScalarTower R S S] {a : S} (ha : IsNilpotent a) (t : R) :
IsNilpotent (t • a) := by
obtain ⟨k, ha⟩ := ha
use k
rw [smul_pow, ha, smul_zero] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.smul | null |
IsNilpotent.isUnit_sub_one [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (r - 1) := by
obtain ⟨n, hn⟩ := hnil
refine ⟨⟨r - 1, -∑ i ∈ Finset.range n, r ^ i, ?_, ?_⟩, rfl⟩
· simp [mul_geom_sum, hn]
· simp [geom_sum_mul, hn] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_sub_one | null |
IsNilpotent.isUnit_one_sub [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (1 - r) := by
rw [← IsUnit.neg_iff, neg_sub]
exact isUnit_sub_one hnil | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_one_sub | null |
IsNilpotent.isUnit_add_one [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (r + 1) := by
rw [← IsUnit.neg_iff, neg_add']
exact isUnit_sub_one hnil.neg | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_add_one | null |
IsNilpotent.isUnit_one_add [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (1 + r) :=
add_comm r 1 ▸ isUnit_add_one hnil | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_one_add | null |
IsNilpotent.isUnit_add_left_of_commute [Ring R] {r u : R}
(hnil : IsNilpotent r) (hu : IsUnit u) (h_comm : Commute r u) :
IsUnit (u + r) := by
rw [← Units.isUnit_mul_units _ hu.unit⁻¹, add_mul, IsUnit.mul_val_inv]
replace h_comm : Commute r (↑hu.unit⁻¹) := Commute.units_inv_right h_comm
refine IsNilpotent.isUnit_one_add ?_
exact (hu.unit⁻¹.isUnit.isNilpotent_mul_unit_of_commute_iff h_comm).mpr hnil | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_add_left_of_commute | null |
IsNilpotent.isUnit_add_right_of_commute [Ring R] {r u : R}
(hnil : IsNilpotent r) (hu : IsUnit u) (h_comm : Commute r u) :
IsUnit (r + u) :=
add_comm r u ▸ hnil.isUnit_add_left_of_commute hu h_comm | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.isUnit_add_right_of_commute | null |
IsUnit.not_isNilpotent [Ring R] [Nontrivial R] {x : R} (hx : IsUnit x) :
¬ IsNilpotent x := by
intro H
simpa using H.isUnit_add_right_of_commute hx.neg (by simp) | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsUnit.not_isNilpotent | null |
IsNilpotent.not_isUnit [Ring R] [Nontrivial R] {x : R} (hx : IsNilpotent x) :
¬ IsUnit x :=
mt IsUnit.not_isNilpotent (by simpa only [not_not] using hx) | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsNilpotent.not_isUnit | null |
IsIdempotentElem.eq_zero_of_isNilpotent [MonoidWithZero R] {e : R}
(idem : IsIdempotentElem e) (nilp : IsNilpotent e) : e = 0 := by
obtain ⟨rfl | n, hn⟩ := nilp
· rw [pow_zero] at hn; rw [← one_mul e, hn, zero_mul]
· rw [← hn, idem.pow_succ_eq]
alias IsNilpotent.eq_zero_of_isIdempotentElem := IsIdempotentElem.eq_zero_of_isNilpotent | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsIdempotentElem.eq_zero_of_isNilpotent | null |
Prime.isRadical [CommMonoidWithZero R] {y : R} (hy : Prime y) : IsRadical y :=
fun _ _ ↦ hy.dvd_of_dvd_pow | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | Prime.isRadical | null |
zero_isRadical_iff [MonoidWithZero R] : IsRadical (0 : R) ↔ IsReduced R := by
simp_rw [isReduced_iff, IsNilpotent, exists_imp, ← zero_dvd_iff]
exact forall_swap | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | zero_isRadical_iff | null |
isReduced_iff_pow_one_lt [MonoidWithZero R] (k : ℕ) (hk : 1 < k) :
IsReduced R ↔ ∀ x : R, x ^ k = 0 → x = 0 := by
simp_rw [← zero_isRadical_iff, isRadical_iff_pow_one_lt k hk, zero_dvd_iff] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isReduced_iff_pow_one_lt | null |
IsRadical.of_dvd [CancelCommMonoidWithZero R] {x y : R} (hy : IsRadical y) (h0 : y ≠ 0)
(hxy : x ∣ y) : IsRadical x := (isRadical_iff_pow_one_lt 2 one_lt_two).2 <| by
obtain ⟨z, rfl⟩ := hxy
refine fun w dvd ↦ ((mul_dvd_mul_iff_right <| right_ne_zero_of_mul h0).mp <| hy 2 _ ?_)
rw [mul_pow]
gcongr
exact dvd_pow_self _ two_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | IsRadical.of_dvd | null |
add_pow_eq_zero_of_add_le_succ_of_pow_eq_zero (h_comm : Commute x y) {m n k : ℕ}
(hx : x ^ m = 0) (hy : y ^ n = 0) (h : m + n ≤ k + 1) :
(x + y) ^ k = 0 := by
rw [h_comm.add_pow']
apply Finset.sum_eq_zero
rintro ⟨i, j⟩ hij
suffices x ^ i * y ^ j = 0 by simp only [this, nsmul_eq_mul, mul_zero]
by_cases hi : m ≤ i
· rw [pow_eq_zero_of_le hi hx, zero_mul]
rw [pow_eq_zero_of_le ?_ hy, mul_zero]
linarith [Finset.mem_antidiagonal.mp hij] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | add_pow_eq_zero_of_add_le_succ_of_pow_eq_zero | null |
add_pow_add_eq_zero_of_pow_eq_zero (h_comm : Commute x y) {m n : ℕ}
(hx : x ^ m = 0) (hy : y ^ n = 0) :
(x + y) ^ (m + n - 1) = 0 :=
h_comm.add_pow_eq_zero_of_add_le_succ_of_pow_eq_zero hx hy <| by rw [← Nat.sub_le_iff_le_add] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | add_pow_add_eq_zero_of_pow_eq_zero | null |
isNilpotent_add (h_comm : Commute x y) (hx : IsNilpotent x) (hy : IsNilpotent y) :
IsNilpotent (x + y) := by
obtain ⟨n, hn⟩ := hx
obtain ⟨m, hm⟩ := hy
exact ⟨_, add_pow_add_eq_zero_of_pow_eq_zero h_comm hn hm⟩ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_add | null |
protected isNilpotent_sum {ι : Type*} {s : Finset ι} {f : ι → R}
(hnp : ∀ i ∈ s, IsNilpotent (f i)) (h_comm : ∀ i j, i ∈ s → j ∈ s → Commute (f i) (f j)) :
IsNilpotent (∑ i ∈ s, f i) := by
classical
induction s using Finset.induction with
| empty => simp
| insert j s hj ih => ?_
rw [Finset.sum_insert hj]
apply Commute.isNilpotent_add
· exact Commute.sum_right _ _ _ (fun i hi ↦ h_comm _ _ (by simp) (by simp [hi]))
· apply hnp; simp
· exact ih (fun i hi ↦ hnp i (by simp [hi]))
(fun i j hi hj ↦ h_comm i j (by simp [hi]) (by simp [hj])) | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_sum | null |
isNilpotent_finsum {ι : Type*} {f : ι → R}
(hf : ∀ b, IsNilpotent (f b)) (h_comm : ∀ i j, Commute (f i) (f j)) :
IsNilpotent (finsum f) := by
classical
by_cases h : Set.Finite f.support
· rw [finsum_def, dif_pos h]
exact Commute.isNilpotent_sum (fun b _ ↦ hf b) (fun _ _ _ _ ↦ h_comm _ _)
· simp only [finsum_def, dif_neg h, IsNilpotent.zero] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_finsum | null |
protected isNilpotent_mul_right_iff (h_comm : Commute x y) (hy : y ∈ nonZeroDivisorsRight R) :
IsNilpotent (x * y) ↔ IsNilpotent x := by
refine ⟨?_, h_comm.isNilpotent_mul_right⟩
rintro ⟨k, hk⟩
rw [mul_pow h_comm] at hk
exact ⟨k, (nonZeroDivisorsRight R).pow_mem hy k _ hk⟩ | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_mul_right_iff | null |
protected isNilpotent_mul_left_iff (h_comm : Commute x y) (hx : x ∈ nonZeroDivisorsLeft R) :
IsNilpotent (x * y) ↔ IsNilpotent y := by
refine ⟨?_, h_comm.isNilpotent_mul_left⟩
rintro ⟨k, hk⟩
rw [mul_pow h_comm] at hk
exact ⟨k, (nonZeroDivisorsLeft R).pow_mem hx k _ hk⟩ | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_mul_left_iff | null |
isNilpotent_sub (h_comm : Commute x y) (hx : IsNilpotent x) (hy : IsNilpotent y) :
IsNilpotent (x - y) := by
rw [← neg_right_iff] at h_comm
rw [← isNilpotent_neg_iff] at hy
rw [sub_eq_add_neg]
exact h_comm.isNilpotent_add hx hy | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_sub | null |
isNilpotent_sum {ι : Type*} {s : Finset ι} {f : ι → R}
(hnp : ∀ i ∈ s, IsNilpotent (f i)) :
IsNilpotent (∑ i ∈ s, f i) :=
Commute.isNilpotent_sum hnp fun _ _ _ _ ↦ Commute.all _ _ | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_sum | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.