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 ⌀ |
|---|---|---|---|---|---|---|
coe_monomial (n : σ →₀ ℕ) (a : R) :
(monomial n a : MvPowerSeries σ R) = MvPowerSeries.monomial n a :=
MvPowerSeries.ext fun m => by
classical
rw [coeff_coe, coeff_monomial, MvPowerSeries.coeff_monomial]
split_ifs with h₁ h₂ <;> first | rfl | subst m; contradiction
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_monomial | null |
coe_zero : ((0 : MvPolynomial σ R) : MvPowerSeries σ R) = 0 :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_zero | null |
coe_one : ((1 : MvPolynomial σ R) : MvPowerSeries σ R) = 1 :=
coe_monomial _ _
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_one | null |
coe_add : ((φ + ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ + ψ :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_add | null |
coe_mul : ((φ * ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ * ψ :=
MvPowerSeries.ext fun n => by
classical
simp only [coeff_coe, MvPowerSeries.coeff_mul, coeff_mul]
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_mul | null |
coe_C (a : R) : ((C a : MvPolynomial σ R) : MvPowerSeries σ R) = MvPowerSeries.C a :=
coe_monomial _ _
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_C | null |
coe_X (s : σ) : ((X s : MvPolynomial σ R) : MvPowerSeries σ R) = MvPowerSeries.X s :=
coe_monomial _ _
variable (σ R) | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_X | null |
coe_injective : Function.Injective ((↑) : MvPolynomial σ R → MvPowerSeries σ R) := by
intro x y h
ext
simp_rw [← coeff_coe, h]
variable {σ R φ ψ}
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_injective | null |
coe_inj : (φ : MvPowerSeries σ R) = ψ ↔ φ = ψ :=
(coe_injective σ R).eq_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_inj | null |
coe_eq_zero_iff : (φ : MvPowerSeries σ R) = 0 ↔ φ = 0 := by rw [← coe_zero, coe_inj]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_eq_zero_iff | null |
coe_eq_one_iff : (φ : MvPowerSeries σ R) = 1 ↔ φ = 1 := by rw [← coe_one, coe_inj] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_eq_one_iff | null |
coeToMvPowerSeries.ringHom : MvPolynomial σ R →+* MvPowerSeries σ R where
toFun := (Coe.coe : MvPolynomial σ R → MvPowerSeries σ R)
map_zero' := coe_zero
map_one' := coe_one
map_add' := coe_add
map_mul' := coe_mul
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coeToMvPowerSeries.ringHom | The coercion from multivariate polynomials to multivariate power series
as a ring homomorphism. |
coe_pow (n : ℕ) :
((φ ^ n : MvPolynomial σ R) : MvPowerSeries σ R) = (φ : MvPowerSeries σ R) ^ n :=
coeToMvPowerSeries.ringHom.map_pow _ _
variable (φ ψ)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coe_pow | null |
coeToMvPowerSeries.ringHom_apply : coeToMvPowerSeries.ringHom φ = φ :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coeToMvPowerSeries.ringHom_apply | null |
_root_.MvPowerSeries.monomial_one_eq
(e : σ →₀ ℕ) :
MvPowerSeries.monomial e (1 : R) =
e.prod fun s n ↦ (MvPowerSeries.X s) ^ n := by
simp only [← coe_X, ← coe_pow, ← coe_monomial, monomial_eq, map_one, one_mul]
simp only [← coeToMvPowerSeries.ringHom_apply, ← map_finsuppProd] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | _root_.MvPowerSeries.monomial_one_eq | null |
coeToMvPowerSeries.algHom : MvPolynomial σ R →ₐ[R] MvPowerSeries σ A :=
{ (MvPowerSeries.map (algebraMap R A)).comp coeToMvPowerSeries.ringHom with
commutes' := fun r => by simp [MvPowerSeries.algebraMap_apply] }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coeToMvPowerSeries.algHom | The coercion from multivariate polynomials to multivariate power series
as an algebra homomorphism. |
coeToMvPowerSeries.algHom_apply :
coeToMvPowerSeries.algHom A φ = MvPowerSeries.map (algebraMap R A) ↑φ :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | coeToMvPowerSeries.algHom_apply | null |
_root_.MvPowerSeries.prod_smul_X_eq_smul_monomial_one
{A : Type*} [CommSemiring A] [Algebra A R] (e : σ →₀ ℕ) (a : σ → A) :
e.prod (fun s n ↦ ((a s • MvPowerSeries.X s) ^ n))
= (e.prod fun s n ↦ (a s) ^ n) • MvPowerSeries.monomial (R := R) e 1 := by
rw [Finsupp.prod_congr
(g2 := fun s n ↦ ((MvPowerSeries.C (algebraMap A R (a s)) * (MvPowerSeries.X s)) ^ n))]
· have (a : A) (f : MvPowerSeries σ R) : a • f =
MvPowerSeries.C ((algebraMap A R) a) * f := by
rw [← MvPowerSeries.smul_eq_C_mul, IsScalarTower.algebraMap_smul]
simp only [mul_pow, Finsupp.prod_mul, ← map_pow, ← MvPowerSeries.monomial_one_eq, this]
simp only [map_finsuppProd, map_pow]
· intro x _
rw [algebra_compatible_smul R, MvPowerSeries.smul_eq_C_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | _root_.MvPowerSeries.prod_smul_X_eq_smul_monomial_one | null |
_root_.MvPowerSeries.monomial_eq (e : σ →₀ ℕ) (r : σ → R) :
MvPowerSeries.monomial e (e.prod (fun s n => r s ^ n))
= e.prod fun s e => (r s • MvPowerSeries.X s) ^ e := by
rw [MvPowerSeries.prod_smul_X_eq_smul_monomial_one, ← map_smul, smul_eq_mul, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | _root_.MvPowerSeries.monomial_eq | null |
_root_.MvPowerSeries.monomial_smul_const
{σ : Type*} {R : Type*} [CommSemiring R]
(e : σ →₀ ℕ) (r : R) :
MvPowerSeries.monomial e (r ^ (e.sum fun _ n => n))
= (e.prod fun s e => (r • MvPowerSeries.X s) ^ e) := by
rw [MvPowerSeries.prod_smul_X_eq_smul_monomial_one, ← map_smul, smul_eq_mul, mul_one]
simp only [Finsupp.sum, Finsupp.prod, Finset.prod_pow_eq_pow_sum] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | _root_.MvPowerSeries.monomial_smul_const | null |
algebraMvPolynomial : Algebra (MvPolynomial σ R) (MvPowerSeries σ A) :=
RingHom.toAlgebra (MvPolynomial.coeToMvPowerSeries.algHom A).toRingHom | instance | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | algebraMvPolynomial | null |
algebraMvPowerSeries : Algebra (MvPowerSeries σ R) (MvPowerSeries σ A) :=
(map (algebraMap R A)).toAlgebra
variable (A) | instance | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | algebraMvPowerSeries | null |
algebraMap_apply' (p : MvPolynomial σ R) :
algebraMap (MvPolynomial σ R) (MvPowerSeries σ A) p = map (algebraMap R A) p :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | algebraMap_apply' | null |
algebraMap_apply'' :
algebraMap (MvPowerSeries σ R) (MvPowerSeries σ A) f = map (algebraMap R A) f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Order.Antidiag.Finsupp",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.Tactic.Linarith",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPowerSeries/Basic.lean | algebraMap_apply'' | null |
@[mk_iff hasEval_def]
HasEval (a : σ → S) : Prop where
hpow : ∀ s, IsTopologicallyNilpotent (a s)
tendsto_zero : Tendsto a cofinite (𝓝 0) | structure | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval | Families at which power series can be consistently evaluated |
HasEval.mono {S : Type*} [CommRing S] {a : σ → S}
{t u : TopologicalSpace S} (h : t ≤ u) (ha : @HasEval _ _ _ t a) :
@HasEval _ _ _ u a :=
⟨fun s ↦ Filter.Tendsto.mono_right (@HasEval.hpow _ _ _ t a ha s) (nhds_mono h),
Filter.Tendsto.mono_right (@HasEval.tendsto_zero σ _ _ t a ha) (nhds_mono h)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.mono | null |
HasEval.zero : HasEval (0 : σ → S) where
hpow _ := .zero
tendsto_zero := tendsto_const_nhds | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.zero | null |
HasEval.add [ContinuousAdd S] [IsLinearTopology S S]
{a b : σ → S} (ha : HasEval a) (hb : HasEval b) : HasEval (a + b) where
hpow s := (ha.hpow s).add (hb.hpow s)
tendsto_zero := by rw [← add_zero 0]; exact ha.tendsto_zero.add hb.tendsto_zero | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.add | null |
HasEval.mul_left [IsLinearTopology S S]
(c : σ → S) {x : σ → S} (hx : HasEval x) : HasEval (c * x) where
hpow s := (hx.hpow s).mul_left (c s)
tendsto_zero := IsLinearTopology.tendsto_mul_zero_of_right _ _ hx.tendsto_zero | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.mul_left | null |
HasEval.mul_right [IsLinearTopology S S]
(c : σ → S) {x : σ → S} (hx : HasEval x) : HasEval (x * c) :=
mul_comm x c ▸ HasEval.mul_left c hx | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.mul_right | null |
HasEval.map (hφ : Continuous φ) {a : σ → R} (ha : HasEval a) :
HasEval (fun s ↦ φ (a s)) where
hpow s := (ha.hpow s).map hφ
tendsto_zero := (map_zero φ ▸ hφ.tendsto 0).comp ha.tendsto_zero | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.map | [Bourbaki, *Algebra*, chap. 4, §4, n°3, Prop. 4 (i) (a & b)][bourbaki1981]. |
protected HasEval.X :
HasEval (fun s ↦ (MvPowerSeries.X s : MvPowerSeries σ R)) where
hpow s := isTopologicallyNilpotent_of_constantCoeff_zero (constantCoeff_X s)
tendsto_zero := variables_tendsto_zero
variable [IsTopologicalRing S] [IsLinearTopology S S] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | HasEval.X | null |
@[simps]
hasEvalIdeal : Ideal (σ → S) where
carrier := {a | HasEval a}
add_mem' := HasEval.add
zero_mem' := HasEval.zero
smul_mem' := HasEval.mul_left | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | hasEvalIdeal | The domain of evaluation of `MvPowerSeries`, as an ideal |
mem_hasEvalIdeal_iff {a : σ → S} :
a ∈ hasEvalIdeal ↔ HasEval a := by
simp [hasEvalIdeal] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | mem_hasEvalIdeal_iff | null |
_root_.MvPolynomial.toMvPowerSeries_uniformContinuous
[IsUniformAddGroup R] [IsUniformAddGroup S] [IsLinearTopology S S]
(hφ : Continuous φ) (ha : HasEval a) :
UniformContinuous (MvPolynomial.eval₂Hom φ a) := by
classical
apply uniformContinuous_of_continuousAt_zero
rw [ContinuousAt, map_zero, IsLinearTopology.hasBasis_ideal.tendsto_right_iff]
intro I hI
let n : σ → ℕ := fun s ↦ sInf {n : ℕ | (a s) ^ n.succ ∈ I}
have hn_ne : ∀ s, Set.Nonempty {n : ℕ | (a s) ^ n.succ ∈ I} := fun s ↦ by
rcases ha.hpow s |>.eventually_mem hI |>.exists_forall_of_atTop with ⟨n, hn⟩
use n
simpa using hn n.succ n.le_succ
have hn : Set.Finite (n.support) := by
change n =ᶠ[cofinite] 0
filter_upwards [ha.tendsto_zero.eventually_mem hI] with s has
simpa [n, Pi.zero_apply, Nat.sInf_eq_zero, or_iff_left (hn_ne s).ne_empty] using has
let n₀ : σ →₀ ℕ := .ofSupportFinite n hn
let D := Iic n₀
have hD : Set.Finite D := finite_Iic _
have : ∀ d ∈ D, ∀ᶠ (p : MvPolynomial σ R) in 𝓝 0, φ (p.coeff d) ∈ I := fun d hd ↦ by
have : Tendsto (φ ∘ coeff d ∘ toMvPowerSeries) (𝓝 0) (𝓝 0) :=
hφ.comp (continuous_coeff R d) |>.comp continuous_induced_dom |>.tendsto' 0 0 (map_zero _)
filter_upwards [this.eventually_mem hI] with f hf
simpa using hf
rw [← hD.eventually_all] at this
filter_upwards [this] with p hp
rw [coe_eval₂Hom, SetLike.mem_coe, eval₂_eq]
apply Ideal.sum_mem
intro d _
by_cases hd : d ∈ D
· exact Ideal.mul_mem_right _ _ (hp d hd)
· apply Ideal.mul_mem_left
simp only [mem_Iic, D, Finsupp.le_iff] at hd
push_neg at hd
rcases hd with ⟨s, hs', hs⟩
exact I.prod_mem hs' (I.pow_mem_of_pow_mem (Nat.sInf_mem (hn_ne s)) hs)
variable (φ a)
open scoped Classical in | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | _root_.MvPolynomial.toMvPowerSeries_uniformContinuous | The induced uniform structure of MvPolynomial σ R is an additive group uniform structure -/
private instance [IsUniformAddGroup R] : IsUniformAddGroup (MvPolynomial σ R) :=
IsUniformAddGroup.comap coeToMvPowerSeries.ringHom
theorem _root_.MvPolynomial.toMvPowerSeries_isUniformInducing :
IsUniformInducing (toMvPowerSeries (σ := σ) (R := R)) :=
(isUniformInducing_iff toMvPowerSeries).mpr rfl
theorem _root_.MvPolynomial.toMvPowerSeries_isDenseInducing :
IsDenseInducing (toMvPowerSeries (σ := σ) (R := R)) :=
toMvPowerSeries_isUniformInducing.isDenseInducing denseRange_toMvPowerSeries
variable {a : σ → S}
/- The evaluation map on multivariate polynomials is uniformly continuous
for the uniform structure induced by that on multivariate power series. |
noncomputable eval₂ (f : MvPowerSeries σ R) : S :=
if H : ∃ p : MvPolynomial σ R, p = f then (MvPolynomial.eval₂ φ a H.choose)
else IsDenseInducing.extend toMvPowerSeries_isDenseInducing (MvPolynomial.eval₂ φ a) f
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂ | Evaluation of a multivariate power series at `f` at a point `a : σ → S`.
It coincides with the evaluation of `f` as a polynomial if `f` is the coercion of a polynomial.
Otherwise, it is only relevant if `φ` is continuous and `HasEval a`. |
eval₂_coe (f : MvPolynomial σ R) :
MvPowerSeries.eval₂ φ a f = MvPolynomial.eval₂ φ a f := by
have : ∃ p : MvPolynomial σ R, (p : MvPowerSeries σ R) = f := ⟨f, rfl⟩
rw [eval₂, dif_pos this]
congr
rw [← MvPolynomial.coe_inj, this.choose_spec]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂_coe | null |
eval₂_C (r : R) : eval₂ φ a (C r) = φ r := by
rw [← coe_C, eval₂_coe, MvPolynomial.eval₂_C]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂_C | null |
eval₂_X (s : σ) : eval₂ φ a (X s) = a s := by
rw [← coe_X, eval₂_coe, MvPolynomial.eval₂_X]
variable [IsTopologicalSemiring R] [IsUniformAddGroup R]
[IsUniformAddGroup S] [CompleteSpace S] [T2Space S]
[IsTopologicalRing S] [IsLinearTopology S S]
variable {φ a} | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂_X | null |
noncomputable eval₂Hom (hφ : Continuous φ) (ha : HasEval a) :
MvPowerSeries σ R →+* S :=
IsDenseInducing.extendRingHom (i := coeToMvPowerSeries.ringHom)
toMvPowerSeries_isUniformInducing
denseRange_toMvPowerSeries
(toMvPowerSeries_uniformContinuous hφ ha) | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂Hom | Evaluation of power series at adequate elements, as a `RingHom` |
eval₂Hom_eq_extend (hφ : Continuous φ) (ha : HasEval a) (f : MvPowerSeries σ R) :
eval₂Hom hφ ha f =
toMvPowerSeries_isDenseInducing.extend (MvPolynomial.eval₂ φ a) f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂Hom_eq_extend | null |
coe_eval₂Hom (hφ : Continuous φ) (ha : HasEval a) :
⇑(eval₂Hom hφ ha) = eval₂ φ a := by
ext f
simp only [eval₂Hom_eq_extend, eval₂]
split_ifs with h
· obtain ⟨p, rfl⟩ := h
simpa [MvPolynomial.coe_eval₂Hom] using
toMvPowerSeries_isDenseInducing.extend_eq
(toMvPowerSeries_uniformContinuous hφ ha).continuous p
· rw [← eval₂Hom_eq_extend hφ ha] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | coe_eval₂Hom | null |
uniformContinuous_eval₂ (hφ : Continuous φ) (ha : HasEval a) :
UniformContinuous (eval₂ φ a) := by
rw [← coe_eval₂Hom hφ ha]
exact uniformContinuous_uniformly_extend
toMvPowerSeries_isUniformInducing
denseRange_toMvPowerSeries
(toMvPowerSeries_uniformContinuous hφ ha) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | uniformContinuous_eval₂ | null |
continuous_eval₂ (hφ : Continuous φ) (ha : HasEval a) :
Continuous (eval₂ φ a : MvPowerSeries σ R → S) :=
(uniformContinuous_eval₂ hφ ha).continuous | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | continuous_eval₂ | null |
hasSum_eval₂ (hφ : Continuous φ) (ha : HasEval a) (f : MvPowerSeries σ R) :
HasSum
(fun (d : σ →₀ ℕ) ↦ φ (coeff d f) * (d.prod fun s e => (a s) ^ e))
(MvPowerSeries.eval₂ φ a f) := by
rw [← coe_eval₂Hom hφ ha, eval₂Hom_eq_extend hφ ha]
convert (hasSum_of_monomials_self f).map (eval₂Hom hφ ha) (?_) with d
· simp only [Function.comp_apply, coe_eval₂Hom, ← MvPolynomial.coe_monomial,
eval₂_coe, eval₂_monomial]
· rw [coe_eval₂Hom]; exact continuous_eval₂ hφ ha | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | hasSum_eval₂ | null |
eval₂_eq_tsum (hφ : Continuous φ) (ha : HasEval a) (f : MvPowerSeries σ R) :
MvPowerSeries.eval₂ φ a f =
∑' (d : σ →₀ ℕ), φ (coeff d f) * (d.prod fun s e => (a s) ^ e) :=
(hasSum_eval₂ hφ ha f).tsum_eq.symm | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂_eq_tsum | null |
eval₂_unique (hφ : Continuous φ) (ha : HasEval a)
{ε : MvPowerSeries σ R → S} (hε : Continuous ε)
(h : ∀ p : MvPolynomial σ R, ε p = MvPolynomial.eval₂ φ a p) :
ε = eval₂ φ a := by
rw [← coe_eval₂Hom hφ ha]
exact (toMvPowerSeries_isDenseInducing.extend_unique h hε).symm | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | eval₂_unique | null |
comp_eval₂ (hφ : Continuous φ) (ha : HasEval a)
{T : Type*} [UniformSpace T] [CompleteSpace T] [T2Space T]
[CommRing T] [IsTopologicalRing T] [IsLinearTopology T T] [IsUniformAddGroup T]
{ε : S →+* T} (hε : Continuous ε) :
ε ∘ eval₂ φ a = eval₂ (ε.comp φ) (ε ∘ a) := by
apply eval₂_unique _ (ha.map hε)
· exact Continuous.comp hε (continuous_eval₂ hφ ha)
· intro p
simp only [Function.comp_apply, eval₂_coe]
rw [← MvPolynomial.coe_eval₂Hom, ← comp_apply, MvPolynomial.comp_eval₂Hom,
MvPolynomial.coe_eval₂Hom]
· simp only [coe_comp, Continuous.comp hε hφ]
variable [Algebra R S] [ContinuousSMul R S] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | comp_eval₂ | null |
noncomputable aeval (ha : HasEval a) : MvPowerSeries σ R →ₐ[R] S where
toRingHom := MvPowerSeries.eval₂Hom (continuous_algebraMap R S) ha
commutes' r := by
simp only [toMonoidHom_eq_coe, OneHom.toFun_eq_coe, MonoidHom.toOneHom_coe, MonoidHom.coe_coe]
rw [← c_eq_algebraMap, coe_eval₂Hom, eval₂_C] | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | aeval | Evaluation of power series at adequate elements, as an `AlgHom` |
coe_aeval (ha : HasEval a) :
↑(aeval ha) = eval₂ (algebraMap R S) a := by
simp only [aeval, AlgHom.coe_mk, coe_eval₂Hom] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | coe_aeval | null |
continuous_aeval (ha : HasEval a) :
Continuous (aeval ha : MvPowerSeries σ R → S) := by
rw [coe_aeval]
exact continuous_eval₂ (continuous_algebraMap R S) ha
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | continuous_aeval | null |
aeval_coe (ha : HasEval a) (p : MvPolynomial σ R) :
aeval ha (p : MvPowerSeries σ R) = p.aeval a := by
rw [coe_aeval, aeval_def, eval₂_coe] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | aeval_coe | null |
aeval_unique {ε : MvPowerSeries σ R →ₐ[R] S} (hε : Continuous ε) :
aeval (HasEval.X.map hε) = ε := by
apply DFunLike.ext'
rw [coe_aeval]
refine (eval₂_unique (continuous_algebraMap R S) (HasEval.X.map hε) hε ?_).symm
intro p
trans ε.comp (coeToMvPowerSeries.algHom R) p
· simp
conv_lhs => rw [← p.aeval_X_left_apply, MvPolynomial.comp_aeval_apply, MvPolynomial.aeval_def]
simp | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | aeval_unique | null |
hasSum_aeval (ha : HasEval a) (f : MvPowerSeries σ R) :
HasSum (fun (d : σ →₀ ℕ) ↦ (coeff d f) • (d.prod fun s e => (a s) ^ e))
(MvPowerSeries.aeval ha f) := by
simp_rw [coe_aeval, ← algebraMap_smul (R := R) S, smul_eq_mul]
exact hasSum_eval₂ (continuous_algebraMap R S) ha f | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | hasSum_aeval | null |
aeval_eq_sum (ha : HasEval a) (f : MvPowerSeries σ R) :
MvPowerSeries.aeval ha f =
tsum (fun (d : σ →₀ ℕ) ↦ (coeff d f) • (d.prod fun s e => (a s) ^ e)) :=
(hasSum_aeval ha f).tsum_eq.symm | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | aeval_eq_sum | null |
comp_aeval (ha : HasEval a)
{T : Type*} [CommRing T] [UniformSpace T] [IsUniformAddGroup T]
[IsTopologicalRing T] [IsLinearTopology T T]
[T2Space T] [Algebra R T] [ContinuousSMul R T] [CompleteSpace T]
{ε : S →ₐ[R] T} (hε : Continuous ε) :
ε.comp (aeval ha) = aeval (ha.map hε) := by
apply DFunLike.ext'
simp only [AlgHom.coe_comp, coe_aeval ha]
rw [← RingHom.coe_coe,
comp_eval₂ (continuous_algebraMap R S) ha (show Continuous (ε : S →+* T) from hε), coe_aeval]
congr!
simp only [AlgHom.comp_algebraMap_of_tower] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.TopologicallyNilpotent",
"Mathlib.Topology.Algebra.LinearTopology",
"... | Mathlib/RingTheory/MvPowerSeries/Evaluation.lean | comp_aeval | null |
protected noncomputable inv.aux (a : R) (φ : MvPowerSeries σ R) : MvPowerSeries σ R
| n =>
letI := Classical.decEq σ
if n = 0 then a
else
-a *
∑ x ∈ antidiagonal n, if _ : x.2 < n then coeff x.1 φ * inv.aux a φ x.2 else 0
termination_by n => n | def | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | inv.aux | Auxiliary definition that unifies
the totalised inverse formal power series `(_)⁻¹` and
the inverse formal power series that depends on
an inverse of the constant coefficient `invOfUnit`. |
coeff_inv_aux [DecidableEq σ] (n : σ →₀ ℕ) (a : R) (φ : MvPowerSeries σ R) :
coeff n (inv.aux a φ) =
if n = 0 then a
else
-a *
∑ x ∈ antidiagonal n, if x.2 < n then coeff x.1 φ * coeff x.2 (inv.aux a φ) else 0 :=
show inv.aux a φ n = _ by
cases Subsingleton.elim ‹DecidableEq σ› (Classical.decEq σ)
rw [inv.aux]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | coeff_inv_aux | null |
invOfUnit (φ : MvPowerSeries σ R) (u : Rˣ) : MvPowerSeries σ R :=
inv.aux (↑u⁻¹) φ | def | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | invOfUnit | A multivariate formal power series is invertible if the constant coefficient is invertible. |
coeff_invOfUnit [DecidableEq σ] (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (u : Rˣ) :
coeff n (invOfUnit φ u) =
if n = 0 then ↑u⁻¹
else
-↑u⁻¹ *
∑ x ∈ antidiagonal n,
if x.2 < n then coeff x.1 φ * coeff x.2 (invOfUnit φ u) else 0 := by
convert coeff_inv_aux n (↑u⁻¹) φ
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | coeff_invOfUnit | null |
constantCoeff_invOfUnit (φ : MvPowerSeries σ R) (u : Rˣ) :
constantCoeff (invOfUnit φ u) = ↑u⁻¹ := by
classical
rw [← coeff_zero_eq_constantCoeff_apply, coeff_invOfUnit, if_pos rfl]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | constantCoeff_invOfUnit | null |
mul_invOfUnit (φ : MvPowerSeries σ R) (u : Rˣ) (h : constantCoeff φ = u) :
φ * invOfUnit φ u = 1 :=
ext fun n =>
letI := Classical.decEq (σ →₀ ℕ)
if H : n = 0 then by
rw [H]
simp [h]
else by
classical
have : ((0 : σ →₀ ℕ), n) ∈ antidiagonal n := by rw [mem_antidiagonal, zero_add]
rw [coeff_one, if_neg H, coeff_mul, ← Finset.insert_erase this,
Finset.sum_insert (Finset.notMem_erase _ _), coeff_zero_eq_constantCoeff_apply, h,
coeff_invOfUnit, if_neg H, neg_mul, mul_neg, Units.mul_inv_cancel_left, ←
Finset.insert_erase this, Finset.sum_insert (Finset.notMem_erase _ _),
Finset.insert_erase this, if_neg (not_lt_of_ge <| le_rfl), zero_add, add_comm, ←
sub_eq_add_neg, sub_eq_zero, Finset.sum_congr rfl]
rintro ⟨i, j⟩ hij
rw [Finset.mem_erase, mem_antidiagonal] at hij
obtain ⟨h₁, h₂⟩ := hij
subst n
rw [if_pos]
suffices 0 + j < i + j by simpa
apply add_lt_add_right
constructor
· intro s
exact Nat.zero_le _
· intro H
apply h₁
suffices i = 0 by simp [this]
ext1 s
exact Nat.eq_zero_of_le_zero (H s)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | mul_invOfUnit | null |
invOfUnit_mul (φ : MvPowerSeries σ R) (u : Rˣ) (h : constantCoeff φ = u) :
invOfUnit φ u * φ = 1 := by
rw [← mul_cancel_right_mem_nonZeroDivisors (r := φ.invOfUnit u), mul_assoc, one_mul,
mul_invOfUnit _ _ h, mul_one]
apply mem_nonZeroDivisors_of_constantCoeff
simp only [constantCoeff_invOfUnit, IsUnit.mem_nonZeroDivisors (Units.isUnit u⁻¹)] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | invOfUnit_mul | null |
isUnit_iff_constantCoeff {φ : MvPowerSeries σ R} :
IsUnit φ ↔ IsUnit (constantCoeff φ) := by
constructor
· exact IsUnit.map _
· intro ⟨u, hu⟩
exact ⟨⟨_, φ.invOfUnit u, mul_invOfUnit φ u hu.symm, invOfUnit_mul φ u hu.symm⟩, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | isUnit_iff_constantCoeff | null |
@[instance]
map.isLocalHom : IsLocalHom (map (σ := σ) f) :=
⟨by
rintro φ ⟨ψ, h⟩
replace h := congr_arg constantCoeff h
rw [constantCoeff_map] at h
have : IsUnit (constantCoeff ψ.val) := isUnit_constantCoeff _ ψ.isUnit
rw [h] at this
rcases isUnit_of_map_unit f _ this with ⟨c, hc⟩
exact isUnit_of_mul_eq_one φ (invOfUnit φ c) (mul_invOfUnit φ c hc.symm)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | map.isLocalHom | Multivariate formal power series over a local ring form a local ring. -/
instance [IsLocalRing R] : IsLocalRing (MvPowerSeries σ R) :=
IsLocalRing.of_isUnit_or_isUnit_one_sub_self <| by
intro φ
obtain ⟨u, h⟩ | ⟨u, h⟩ := IsLocalRing.isUnit_or_isUnit_one_sub_self (constantCoeff φ) <;>
[left; right] <;>
· refine isUnit_of_mul_eq_one _ _ (mul_invOfUnit _ u ?_)
simpa using h.symm
-- TODO(jmc): once adic topology lands, show that this is complete
end CommRing
section IsLocalRing
variable {S : Type*} [CommRing R] [CommRing S] (f : R →+* S) [IsLocalHom f]
-- Thanks to the linter for informing us that this instance does
-- not actually need R and S to be local rings!
/-- The map between multivariate formal power series over the same indexing set
induced by a local ring hom `A → B` is local |
protected inv (φ : MvPowerSeries σ k) : MvPowerSeries σ k :=
inv.aux (constantCoeff φ)⁻¹ φ | def | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | inv | The inverse `1/f` of a multivariable power series `f` over a field |
coeff_inv [DecidableEq σ] (n : σ →₀ ℕ) (φ : MvPowerSeries σ k) :
coeff n φ⁻¹ =
if n = 0 then (constantCoeff φ)⁻¹
else
-(constantCoeff φ)⁻¹ *
∑ x ∈ antidiagonal n, if x.2 < n then coeff x.1 φ * coeff x.2 φ⁻¹ else 0 :=
coeff_inv_aux n _ φ
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | coeff_inv | null |
constantCoeff_inv (φ : MvPowerSeries σ k) :
constantCoeff φ⁻¹ = (constantCoeff φ)⁻¹ := by
classical
rw [← coeff_zero_eq_constantCoeff_apply, coeff_inv, if_pos rfl] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | constantCoeff_inv | null |
inv_eq_zero {φ : MvPowerSeries σ k} : φ⁻¹ = 0 ↔ constantCoeff φ = 0 :=
⟨fun h => by simpa using congr_arg constantCoeff h, fun h =>
ext fun n => by
classical
rw [coeff_inv]
split_ifs <;>
simp only [h, map_zero, zero_mul, inv_zero, neg_zero]⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | inv_eq_zero | null |
zero_inv : (0 : MvPowerSeries σ k)⁻¹ = 0 := by
rw [inv_eq_zero, constantCoeff_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | zero_inv | null |
invOfUnit_eq (φ : MvPowerSeries σ k) (h : constantCoeff φ ≠ 0) :
invOfUnit φ (Units.mk0 _ h) = φ⁻¹ :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | invOfUnit_eq | null |
invOfUnit_eq' (φ : MvPowerSeries σ k) (u : Units k) (h : constantCoeff φ = u) :
invOfUnit φ u = φ⁻¹ := by
rw [← invOfUnit_eq φ (h.symm ▸ u.ne_zero)]
apply congrArg (invOfUnit φ)
rw [Units.ext_iff]
exact h.symm
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | invOfUnit_eq' | null |
protected mul_inv_cancel (φ : MvPowerSeries σ k) (h : constantCoeff φ ≠ 0) :
φ * φ⁻¹ = 1 := by rw [← invOfUnit_eq φ h, mul_invOfUnit φ (Units.mk0 _ h) rfl]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | mul_inv_cancel | null |
protected inv_mul_cancel (φ : MvPowerSeries σ k) (h : constantCoeff φ ≠ 0) :
φ⁻¹ * φ = 1 := by rw [mul_comm, φ.mul_inv_cancel h] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | inv_mul_cancel | null |
protected eq_mul_inv_iff_mul_eq {φ₁ φ₂ φ₃ : MvPowerSeries σ k}
(h : constantCoeff φ₃ ≠ 0) : φ₁ = φ₂ * φ₃⁻¹ ↔ φ₁ * φ₃ = φ₂ :=
⟨fun k => by simp [k, mul_assoc, MvPowerSeries.inv_mul_cancel _ h], fun k => by
simp [← k, mul_assoc, MvPowerSeries.mul_inv_cancel _ h]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | eq_mul_inv_iff_mul_eq | null |
protected eq_inv_iff_mul_eq_one {φ ψ : MvPowerSeries σ k} (h : constantCoeff ψ ≠ 0) :
φ = ψ⁻¹ ↔ φ * ψ = 1 := by rw [← MvPowerSeries.eq_mul_inv_iff_mul_eq h, one_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | eq_inv_iff_mul_eq_one | null |
protected inv_eq_iff_mul_eq_one {φ ψ : MvPowerSeries σ k} (h : constantCoeff ψ ≠ 0) :
ψ⁻¹ = φ ↔ φ * ψ = 1 := by rw [eq_comm, MvPowerSeries.eq_inv_iff_mul_eq_one h]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | inv_eq_iff_mul_eq_one | null |
protected mul_inv_rev (φ ψ : MvPowerSeries σ k) :
(φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹ := by
by_cases h : constantCoeff (φ * ψ) = 0
· rw [inv_eq_zero.mpr h]
simp only [map_mul, mul_eq_zero] at h
rcases h with h | h <;> simp [inv_eq_zero.mpr h]
· rw [MvPowerSeries.inv_eq_iff_mul_eq_one h]
simp only [not_or, map_mul, mul_eq_zero] at h
rw [← mul_assoc, mul_assoc _⁻¹, MvPowerSeries.inv_mul_cancel _ h.left, mul_one,
MvPowerSeries.inv_mul_cancel _ h.right] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | mul_inv_rev | null |
@[simp]
C_inv (r : k) : (C (σ := σ) r)⁻¹ = C r⁻¹ := by
rcases eq_or_ne r 0 with (rfl | hr)
· simp
rw [MvPowerSeries.inv_eq_iff_mul_eq_one, ← map_mul, inv_mul_cancel₀ hr, map_one]
simpa using hr
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | C_inv | null |
X_inv (s : σ) : (X s : MvPowerSeries σ k)⁻¹ = 0 := by
rw [inv_eq_zero, constantCoeff_X]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | X_inv | null |
smul_inv (r : k) (φ : MvPowerSeries σ k) : (r • φ)⁻¹ = r⁻¹ • φ⁻¹ := by
simp [smul_eq_C_mul, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Inverse.lean | smul_inv | null |
noncomputable lexOrder (φ : MvPowerSeries σ R) : (WithTop (Lex (σ →₀ ℕ))) := by
classical
exact if h : φ = 0 then ⊤ else by
have ne : Set.Nonempty (toLex '' φ.support) := by
simp only [Set.image_nonempty, Function.support_nonempty_iff, ne_eq, h, not_false_eq_true]
apply WithTop.some
apply WellFounded.min _ (toLex '' φ.support) ne
· exact Finsupp.instLTLex.lt
· exact wellFounded_lt | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder | The lex order on multivariate power series. |
lexOrder_def_of_ne_zero {φ : MvPowerSeries σ R} (hφ : φ ≠ 0) :
∃ (ne : Set.Nonempty (toLex '' φ.support)),
lexOrder φ = WithTop.some ((@wellFounded_lt (Lex (σ →₀ ℕ))
(instLTLex) (Lex.wellFoundedLT)).min (toLex '' φ.support) ne) := by
suffices ne : Set.Nonempty (toLex '' φ.support) by
use ne
unfold lexOrder
simp only [dif_neg hφ]
simp only [Set.image_nonempty, Function.support_nonempty_iff, ne_eq, hφ, not_false_eq_true]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder_def_of_ne_zero | null |
lexOrder_eq_top_iff_eq_zero (φ : MvPowerSeries σ R) :
lexOrder φ = ⊤ ↔ φ = 0 := by
unfold lexOrder
split_ifs with h
· simp only [h]
· simp only [h, WithTop.coe_ne_top] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder_eq_top_iff_eq_zero | null |
lexOrder_zero : lexOrder (0 : MvPowerSeries σ R) = ⊤ := by
unfold lexOrder
rw [dif_pos rfl] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder_zero | null |
exists_finsupp_eq_lexOrder_of_ne_zero {φ : MvPowerSeries σ R} (hφ : φ ≠ 0) :
∃ (d : σ →₀ ℕ), lexOrder φ = toLex d := by
simp only [ne_eq, ← lexOrder_eq_top_iff_eq_zero, WithTop.ne_top_iff_exists] at hφ
obtain ⟨p, hp⟩ := hφ
exact ⟨ofLex p, by simp only [toLex_ofLex, hp]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | exists_finsupp_eq_lexOrder_of_ne_zero | null |
coeff_ne_zero_of_lexOrder {φ : MvPowerSeries σ R} {d : σ →₀ ℕ}
(h : toLex d = lexOrder φ) : coeff d φ ≠ 0 := by
have hφ : φ ≠ 0 := by
simp only [ne_eq, ← lexOrder_eq_top_iff_eq_zero, ← h, WithTop.coe_ne_top, not_false_eq_true]
have hφ' := lexOrder_def_of_ne_zero hφ
rcases hφ' with ⟨ne, hφ'⟩
simp only [← h, WithTop.coe_eq_coe] at hφ'
suffices toLex d ∈ toLex '' φ.support by
simp only [Set.mem_image_equiv, toLex_symm_eq, ofLex_toLex, Function.mem_support, ne_eq] at this
apply this
rw [hφ']
apply WellFounded.min_mem | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | coeff_ne_zero_of_lexOrder | null |
coeff_eq_zero_of_lt_lexOrder {φ : MvPowerSeries σ R} {d : σ →₀ ℕ}
(h : toLex d < lexOrder φ) : coeff d φ = 0 := by
by_cases hφ : φ = 0
· simp only [hφ, map_zero]
· rcases lexOrder_def_of_ne_zero hφ with ⟨ne, hφ'⟩
rw [hφ', WithTop.coe_lt_coe] at h
by_contra h'
exact WellFounded.not_lt_min _ (toLex '' φ.support) ne (Set.mem_image_equiv.mpr h') h | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | coeff_eq_zero_of_lt_lexOrder | null |
lexOrder_le_of_coeff_ne_zero {φ : MvPowerSeries σ R} {d : σ →₀ ℕ}
(h : coeff d φ ≠ 0) : lexOrder φ ≤ toLex d := by
rw [← not_lt]
intro h'
exact h (coeff_eq_zero_of_lt_lexOrder h') | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder_le_of_coeff_ne_zero | null |
le_lexOrder_iff {φ : MvPowerSeries σ R} {w : WithTop (Lex (σ →₀ ℕ))} :
w ≤ lexOrder φ ↔ (∀ (d : σ →₀ ℕ) (_ : toLex d < w), coeff d φ = 0) := by
constructor
· intro h d hd
apply coeff_eq_zero_of_lt_lexOrder
exact lt_of_lt_of_le hd h
· intro h
rw [← not_lt]
intro h'
have hφ : φ ≠ 0 := by
rw [ne_eq, ← lexOrder_eq_top_iff_eq_zero]
exact ne_top_of_lt h'
obtain ⟨d, hd⟩ := exists_finsupp_eq_lexOrder_of_ne_zero hφ
refine coeff_ne_zero_of_lexOrder hd.symm (h d ?_)
rwa [← hd] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | le_lexOrder_iff | null |
min_lexOrder_le {φ ψ : MvPowerSeries σ R} :
min (lexOrder φ) (lexOrder ψ) ≤ lexOrder (φ + ψ) := by
rw [le_lexOrder_iff]
intro d hd
simp only [lt_min_iff] at hd
rw [map_add, coeff_eq_zero_of_lt_lexOrder hd.1, coeff_eq_zero_of_lt_lexOrder hd.2, add_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | min_lexOrder_le | null |
coeff_mul_of_add_lexOrder {φ ψ : MvPowerSeries σ R}
{p q : σ →₀ ℕ} (hp : lexOrder φ = toLex p) (hq : lexOrder ψ = toLex q) :
coeff (p + q) (φ * ψ) = coeff p φ * coeff q ψ := by
rw [coeff_mul, Finset.sum_eq_single_of_mem ⟨p, q⟩ (by simp)]
rintro ⟨u, v⟩ h h'
simp only [Finset.mem_antidiagonal] at h
rcases trichotomy_of_add_eq_add (congrArg toLex h) with h'' | h'' | h''
· exact False.elim (h' (by simp [h''.1, h''.2]))
· rw [coeff_eq_zero_of_lt_lexOrder (d := u), zero_mul]
rw [hp]
norm_cast
· rw [coeff_eq_zero_of_lt_lexOrder (d := v), mul_zero]
rw [hq]
norm_cast | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | coeff_mul_of_add_lexOrder | null |
le_lexOrder_mul (φ ψ : MvPowerSeries σ R) :
lexOrder φ + lexOrder ψ ≤ lexOrder (φ * ψ) := by
rw [le_lexOrder_iff]
intro d hd
rw [coeff_mul]
apply Finset.sum_eq_zero
rintro ⟨u, v⟩ h
simp only [Finset.mem_antidiagonal] at h
simp only
suffices toLex u < lexOrder φ ∨ toLex v < lexOrder ψ by
rcases this with (hu | hv)
· rw [coeff_eq_zero_of_lt_lexOrder hu, zero_mul]
· rw [coeff_eq_zero_of_lt_lexOrder hv, mul_zero]
rw [or_iff_not_imp_left, not_lt, ← not_le]
intro hu hv
rw [← not_le] at hd
apply hd
simp only [← h, toLex_add, WithTop.coe_add, add_le_add hu hv]
alias lexOrder_mul_ge := le_lexOrder_mul | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | le_lexOrder_mul | null |
lexOrder_mul [NoZeroDivisors R] (φ ψ : MvPowerSeries σ R) :
lexOrder (φ * ψ) = lexOrder φ + lexOrder ψ := by
by_cases hφ : φ = 0
· simp only [hφ, zero_mul, lexOrder_zero, top_add]
by_cases hψ : ψ = 0
· simp only [hψ, mul_zero, lexOrder_zero, add_top]
rcases exists_finsupp_eq_lexOrder_of_ne_zero hφ with ⟨p, hp⟩
rcases exists_finsupp_eq_lexOrder_of_ne_zero hψ with ⟨q, hq⟩
apply le_antisymm _ (lexOrder_mul_ge φ ψ)
rw [hp, hq]
apply lexOrder_le_of_coeff_ne_zero (d := p + q)
rw [coeff_mul_of_add_lexOrder hp hq, mul_ne_zero_iff]
exact ⟨coeff_ne_zero_of_lexOrder hp.symm, coeff_ne_zero_of_lexOrder hq.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Data.Finsupp.WellFounded"
] | Mathlib/RingTheory/MvPowerSeries/LexOrder.lean | lexOrder_mul | null |
basis (σ : Type*) (R : Type*) [Ring R] (Jd : TwoSidedIdeal R × (σ →₀ ℕ)) :
TwoSidedIdeal (MvPowerSeries σ R) :=
TwoSidedIdeal.mk' {f | ∀ e ≤ Jd.2, coeff e f ∈ Jd.1}
(by simp [coeff_zero])
(fun hf hg e he ↦ by rw [map_add]; exact add_mem (hf e he) (hg e he))
(fun {f} hf e he ↦ by simp only [map_neg, neg_mem, hf e he])
(fun {f g} hg e he ↦ by
classical
rw [coeff_mul]
apply sum_mem
rintro uv huv
exact TwoSidedIdeal.mul_mem_left _ _ _ (hg _ (le_trans (Finset.antidiagonal.snd_le huv) he)))
(fun {f g} hf e he ↦ by
classical
rw [coeff_mul]
apply sum_mem
rintro uv huv
exact TwoSidedIdeal.mul_mem_right _ _ _ (hf _ (le_trans (Finset.antidiagonal.fst_le huv) he)))
variable {σ : Type*} {R : Type*} [Ring R] | def | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | basis | The underlying family for the basis of ideals in a multivariate power series ring. |
mem_basis_iff {f : MvPowerSeries σ R} {Jd : TwoSidedIdeal R × (σ →₀ ℕ)} :
f ∈ basis σ R Jd ↔ ∀ e ≤ Jd.2, coeff e f ∈ Jd.1 := by
simp [basis] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | mem_basis_iff | A power series `f` belongs to the two-sided ideal `basis σ R ⟨J, d⟩`
if and only if `coeff e f ∈ J` for all `e ≤ d`. |
basis_le {Jd Ke : TwoSidedIdeal R × (σ →₀ ℕ)} (hJK : Jd.1 ≤ Ke.1) (hed : Ke.2 ≤ Jd.2) :
basis σ R Jd ≤ basis σ R Ke :=
fun _ ↦ forall_imp (fun _ h hue ↦ hJK (h (le_trans hue hed))) | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | basis_le | If `J ≤ K` and `e ≤ d`, then we have the inclusion of two-sided ideals
`basis σ R ⟨J, d⟩ ≤ basis σ R ⟨K, e,>`. |
basis_le_iff {J K : TwoSidedIdeal R} {d e : σ →₀ ℕ} (hK : K ≠ ⊤) :
basis σ R ⟨J, d⟩ ≤ basis σ R ⟨K, e⟩ ↔ J ≤ K ∧ e ≤ d := by
classical
constructor
· simp only [basis, TwoSidedIdeal.le_iff, TwoSidedIdeal.coe_mk', setOf_subset_setOf]
intro h
constructor
· intro x hx
have (d' : _) : coeff d' (C (σ := σ) x) ∈ J := by
rw [coeff_C]; split_ifs <;> [exact hx; exact J.zero_mem]
simpa using h (C x) (fun _ _ ↦ this _) _ (zero_le _)
· by_contra h'
apply hK
rw [eq_top_iff]
intro x _
have (d') (hd'_le : d' ≤ d) : coeff d' (monomial e x) ∈ J := by
rw [coeff_monomial]
split_ifs with hd' <;> [exact (h' (hd' ▸ hd'_le)).elim; exact J.zero_mem]
simpa using h (monomial e x) this _ le_rfl
· rintro ⟨hJK, hed⟩
exact basis_le hJK hed
variable [TopologicalSpace R]
open WithPiTopology | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | basis_le_iff | `basis σ R ⟨J, d⟩ ≤ basis σ R ⟨K, e⟩` if and only if `J ≤ K` and `e ≤ d`. |
hasBasis_nhds_zero [IsLinearTopology R R] [IsLinearTopology Rᵐᵒᵖ R] :
(𝓝 0 : Filter (MvPowerSeries σ R)).HasBasis
(fun Id : TwoSidedIdeal R × (σ →₀ ℕ) ↦ (Id.1 : Set R) ∈ 𝓝 0)
(fun Id ↦ basis _ _ Id) := by
classical
rw [nhds_pi]
refine IsLinearTopology.hasBasis_twoSidedIdeal.pi_self.to_hasBasis ?_ ?_
· intro ⟨D, I⟩ ⟨hD, hI⟩
refine ⟨⟨I, Finset.sup hD.toFinset id⟩, hI, fun f hf d hd ↦ ?_⟩
rw [SetLike.mem_coe, mem_basis_iff] at hf
convert hf _ <| Finset.le_sup (hD.mem_toFinset.mpr hd)
· intro ⟨I, d⟩ hI
refine ⟨⟨Iic d, I⟩, ⟨finite_Iic d, hI⟩, ?_⟩
simpa [basis, coeff_apply, Iic, Set.pi] using subset_rfl | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | hasBasis_nhds_zero | If the ring `R` is endowed with a linear topology, then the sets `↑basis σ R (J, d)`,
for `J : TwoSidedIdeal R` which are neighborhoods of `0 : R` and `d : σ →₀ ℕ`,
constitute a basis of neighborhoods of `0 : MvPowerSeries σ R` for the product topology. |
isTopologicallyNilpotent_iff_constantCoeff
{R : Type*} [CommRing R] [TopologicalSpace R] [IsLinearTopology R R] (f : MvPowerSeries σ R) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) ↔
IsTopologicallyNilpotent (constantCoeff f) := by
refine ⟨fun H ↦ ?_, isTopologicallyNilpotent_of_constantCoeff⟩
replace H : Tendsto (fun n ↦ constantCoeff (f ^ n)) atTop (nhds 0) :=
continuous_constantCoeff R |>.tendsto' 0 0 constantCoeff_zero |>.comp H
simpa only [map_pow] using H | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Interval",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.Topology.Algebra.LinearTopology",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean | isTopologicallyNilpotent_iff_constantCoeff | The topology on `MvPowerSeries` is a left linear topology
when the ring of coefficients has a linear topology. -/
instance [IsLinearTopology R R] [IsLinearTopology Rᵐᵒᵖ R] :
IsLinearTopology (MvPowerSeries σ R) (MvPowerSeries σ R) :=
IsLinearTopology.mk_of_hasBasis' _ hasBasis_nhds_zero TwoSidedIdeal.mul_mem_left
/-- The topology on `MvPowerSeries` is a right linear topology
when the ring of coefficients has a linear topology. -/
instance [IsLinearTopology R R] [IsLinearTopology Rᵐᵒᵖ R] :
IsLinearTopology (MvPowerSeries σ R)ᵐᵒᵖ (MvPowerSeries σ R) :=
IsLinearTopology.mk_of_hasBasis' _ hasBasis_nhds_zero (fun J _ _ hg ↦ J.mul_mem_right _ _ hg)
theorem isTopologicallyNilpotent_of_constantCoeff
{R : Type*} [CommRing R] [TopologicalSpace R] [IsLinearTopology R R]
{f : MvPowerSeries σ R} (hf : IsTopologicallyNilpotent (constantCoeff f)) :
IsTopologicallyNilpotent f := by
simp_rw [IsTopologicallyNilpotent, tendsto_iff_coeff_tendsto, coeff_zero,
IsLinearTopology.hasBasis_ideal.tendsto_right_iff]
intro d I hI
replace hf := hf.eventually_mem hI
simp_rw [eventually_atTop, SetLike.mem_coe, ← Ideal.Quotient.eq_zero_iff_mem,
map_pow, ← coeff_map, ← constantCoeff_map] at hf ⊢
obtain ⟨N, hN⟩ := hf
use N + d.degree
intro n hn
simpa only [map_pow] using coeff_eq_zero_of_constantCoeff_nilpotent (hN N le_rfl) hn
/-- Assuming the base ring has a linear topology, the powers of a `MvPowerSeries` converge to 0
iff its constant coefficient is topologically nilpotent.
See also `MvPowerSeries.WithPiTopology.isTopologicallyNilpotent_iff_constantCoeff_isNilpotent`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.