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 ⌀ |
|---|---|---|---|---|---|---|
order_eq_nat {φ : R⟦X⟧} {n : ℕ} :
order φ = n ↔ coeff n φ ≠ 0 ∧ ∀ i, i < n → coeff i φ = 0 := by
classical
rcases eq_or_ne φ 0 with (rfl | hφ)
· simp
simp [order, dif_neg hφ, Nat.find_eq_iff] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_eq_nat | The order of a formal power series is exactly `n` if the `n`th coefficient is nonzero,
and the `i`th coefficient is `0` for all `i < n`. |
order_eq {φ : R⟦X⟧} {n : ℕ∞} :
order φ = n ↔ (∀ i : ℕ, ↑i = n → coeff i φ ≠ 0) ∧ ∀ i : ℕ, ↑i < n → coeff i φ = 0 := by
cases n with
| top => simp
| coe n => simp [order_eq_nat] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_eq | The order of a formal power series is exactly `n` if the `n`th coefficient is nonzero,
and the `i`th coefficient is `0` for all `i < n`. |
min_order_le_order_add (φ ψ : R⟦X⟧) : min (order φ) (order ψ) ≤ order (φ + ψ) := by
refine le_order _ _ ?_
simp +contextual [coeff_of_lt_order] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | min_order_le_order_add | The order of the sum of two formal power series
is at least the minimum of their orders. |
private order_add_of_order_ne.aux (φ ψ : R⟦X⟧)
(H : order φ < order ψ) : order (φ + ψ) ≤ order φ ⊓ order ψ := by
suffices order (φ + ψ) = order φ by
rw [le_inf_iff, this]
exact ⟨le_rfl, le_of_lt H⟩
rw [order_eq]
constructor
· intro i hi
rw [← hi] at H
rw [(coeff _).map_add, coeff_of_lt_order i H, add_zero]
exact (order_eq_nat.1 hi.symm).1
· intro i hi
rw [(coeff _).map_add, coeff_of_lt_order i hi, coeff_of_lt_order i (lt_trans hi H),
zero_add] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_add_of_order_ne.aux | null |
order_add_of_order_ne (φ ψ : R⟦X⟧) (h : order φ ≠ order ψ) :
order (φ + ψ) = order φ ⊓ order ψ := by
refine le_antisymm ?_ (min_order_le_order_add _ _)
rcases h.lt_or_gt with (φ_lt_ψ | ψ_lt_φ)
· apply order_add_of_order_ne.aux _ _ φ_lt_ψ
· simpa only [add_comm, inf_comm] using order_add_of_order_ne.aux _ _ ψ_lt_φ
@[deprecated (since := "2025-09-17")] alias order_add_of_order_eq := order_add_of_order_ne | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_add_of_order_ne | The order of the sum of two formal power series
is the minimum of their orders if their orders differ. |
le_order_mul (φ ψ : R⟦X⟧) : order φ + order ψ ≤ order (φ * ψ) := by
apply le_order
intro n hn; rw [coeff_mul, Finset.sum_eq_zero]
rintro ⟨i, j⟩ hij
by_cases hi : ↑i < order φ
· rw [coeff_of_lt_order i hi, zero_mul]
by_cases hj : ↑j < order ψ
· rw [coeff_of_lt_order j hj, mul_zero]
rw [not_lt] at hi hj; rw [mem_antidiagonal] at hij
exfalso
apply ne_of_lt (lt_of_lt_of_le hn <| add_le_add hi hj)
rw [← Nat.cast_add, hij] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | le_order_mul | The order of the product of two formal power series
is at least the sum of their orders. |
le_order_pow (φ : R⟦X⟧) (n : ℕ) : n • order φ ≤ order (φ ^ n) := by
induction n with
| zero => simp
| succ n hn =>
simp only [add_smul, one_smul, pow_succ]
apply le_trans _ (le_order_mul _ _)
exact add_le_add_right hn φ.order | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | le_order_pow | null |
le_order_prod {R : Type*} [CommSemiring R] {ι : Type*} (φ : ι → R⟦X⟧) (s : Finset ι) :
∑ i ∈ s, (φ i).order ≤ (∏ i ∈ s, φ i).order := by
induction s using Finset.cons_induction with
| empty => simp
| cons a s ha ih =>
rw [Finset.sum_cons ha, Finset.prod_cons ha]
exact le_trans (add_le_add_left ih _) (le_order_mul _ _)
alias order_mul_ge := le_order_mul | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | le_order_prod | null |
order_monomial (n : ℕ) (a : R) [Decidable (a = 0)] :
order (monomial n a) = if a = 0 then (⊤ : ℕ∞) else n := by
split_ifs with h
· rw [h, order_eq_top, LinearMap.map_zero]
· rw [order_eq]
constructor <;> intro i hi
· simp only [Nat.cast_inj] at hi
rwa [hi, coeff_monomial_same]
· simp only [Nat.cast_lt] at hi
rw [coeff_monomial, if_neg]
exact ne_of_lt hi | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_monomial | The order of the monomial `a*X^n` is infinite if `a = 0` and `n` otherwise. |
order_monomial_of_ne_zero (n : ℕ) (a : R) (h : a ≠ 0) : order (monomial n a) = n := by
classical
rw [order_monomial, if_neg h] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_monomial_of_ne_zero | The order of the monomial `a*X^n` is `n` if `a ≠ 0`. |
coeff_mul_of_lt_order {φ ψ : R⟦X⟧} {n : ℕ} (h : ↑n < ψ.order) :
coeff n (φ * ψ) = 0 := by
suffices coeff n (φ * ψ) = ∑ p ∈ antidiagonal n, 0 by rw [this, Finset.sum_const_zero]
rw [coeff_mul]
apply Finset.sum_congr rfl
intro x hx
refine mul_eq_zero_of_right (coeff x.fst φ) (coeff_of_lt_order x.snd (lt_of_le_of_lt ?_ h))
rw [mem_antidiagonal] at hx
norm_cast
cutsat | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | coeff_mul_of_lt_order | If `n` is strictly smaller than the order of `ψ`, then the `n`th coefficient of its product
with any other power series is `0`. |
coeff_mul_one_sub_of_lt_order {R : Type*} [Ring R] {φ ψ : R⟦X⟧} (n : ℕ)
(h : ↑n < ψ.order) : coeff n (φ * (1 - ψ)) = coeff n φ := by
simp [coeff_mul_of_lt_order h, mul_sub] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | coeff_mul_one_sub_of_lt_order | null |
coeff_mul_prod_one_sub_of_lt_order {R ι : Type*} [CommRing R] (k : ℕ) (s : Finset ι)
(φ : R⟦X⟧) (f : ι → R⟦X⟧) :
(∀ i ∈ s, ↑k < (f i).order) → coeff k (φ * ∏ i ∈ s, (1 - f i)) = coeff k φ := by
classical
induction s using Finset.induction_on with
| empty => simp
| insert a s ha ih =>
intro t
simp only [Finset.mem_insert, forall_eq_or_imp] at t
rw [Finset.prod_insert ha, ← mul_assoc, mul_right_comm, coeff_mul_one_sub_of_lt_order _ t.1]
exact ih t.2
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | coeff_mul_prod_one_sub_of_lt_order | null |
order_neg {R : Type*} [Ring R] (φ : PowerSeries R) : (-φ).order = φ.order := by
by_contra! h
have : φ = 0 := by simpa using (order_add_of_order_ne _ _ h).symm
simp [this] at h | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_neg | null |
divXPowOrder (f : R⟦X⟧) : R⟦X⟧ :=
.mk fun n ↦ coeff (n + f.order.toNat) f
@[deprecated (since := "2025-04-15")]
noncomputable alias divided_by_X_pow_order := divXPowOrder
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | divXPowOrder | Given a non-zero power series `f`, `divXPowOrder f` is the power series obtained by
dividing out the largest power of X that divides `f`, that is its order |
coeff_divXPowOrder {f : R⟦X⟧} {n : ℕ} :
coeff n (divXPowOrder f) = coeff (n + f.order.toNat) f :=
coeff_mk _ _
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | coeff_divXPowOrder | null |
divXPowOrder_zero :
divXPowOrder (0 : R⟦X⟧) = 0 := by
ext
simp | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | divXPowOrder_zero | null |
constantCoeff_divXPowOrder {f : R⟦X⟧} :
constantCoeff (divXPowOrder f) = coeff f.order.toNat f := by
simp [← coeff_zero_eq_constantCoeff] | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | constantCoeff_divXPowOrder | null |
constantCoeff_divXPowOrder_eq_zero_iff {f : R⟦X⟧} :
constantCoeff (divXPowOrder f) = 0 ↔ f = 0 := by
by_cases h : f = 0
· simp [h]
· simp [constantCoeff_divXPowOrder, coeff_order h, h] | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | constantCoeff_divXPowOrder_eq_zero_iff | null |
X_pow_order_mul_divXPowOrder {f : R⟦X⟧} :
X ^ f.order.toNat * divXPowOrder f = f := by
ext n
rw [coeff_X_pow_mul']
split_ifs with h
· simp [h]
· push_neg at h
rw [coeff_of_lt_order_toNat _ h]
@[deprecated (since := "2025-04-15")]
alias self_eq_X_pow_order_mul_divided_by_X_pow_order := X_pow_order_mul_divXPowOrder | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | X_pow_order_mul_divXPowOrder | null |
X_pow_order_dvd : X ^ φ.order.toNat ∣ φ := by
simpa only [X_pow_dvd_iff] using coeff_of_lt_order_toNat | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | X_pow_order_dvd | null |
order_eq_emultiplicity_X {R : Type*} [Semiring R] (φ : R⟦X⟧) :
order φ = emultiplicity X φ := by
classical
rcases eq_or_ne φ 0 with (rfl | hφ)
· simp
cases ho : order φ with
| top => simp [hφ] at ho
| coe n =>
have hn : φ.order.toNat = n := by simp [ho]
rw [← hn, eq_comm]
apply le_antisymm _
· apply le_emultiplicity_of_pow_dvd
apply X_pow_order_dvd
· apply Order.le_of_lt_add_one
rw [← not_le, ← Nat.cast_one, ← Nat.cast_add, ← pow_dvd_iff_le_emultiplicity]
rintro ⟨ψ, H⟩
have := congr_arg (coeff n) H
rw [X_pow_mul, coeff_mul_of_lt_order, ← hn] at this
· exact coeff_order hφ this
· rw [X_pow_eq, order_monomial]
split_ifs
· simp
· rw [← hn, ENat.coe_lt_coe]
simp | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_eq_emultiplicity_X | null |
@[simp]
order_one : order (1 : R⟦X⟧) = 0 := by
simpa using order_monomial_of_ne_zero 0 (1 : R) one_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_one | The order of the formal power series `1` is `0`. |
order_zero_of_unit {f : R⟦X⟧} : IsUnit f → f.order = 0 := by
rintro ⟨⟨u, v, hu, hv⟩, hf⟩
apply And.left
rw [← add_eq_zero, ← hf, ← nonpos_iff_eq_zero, ← @order_one R _ _, ← hu]
exact order_mul_ge _ _ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_zero_of_unit | The order of an invertible power series is `0`. |
@[simp]
order_X : order (X : R⟦X⟧) = 1 := by
simpa only [Nat.cast_one] using order_monomial_of_ne_zero 1 (1 : R) one_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_X | The order of the formal power series `X` is `1`. |
@[simp]
order_X_pow (n : ℕ) : order ((X : R⟦X⟧) ^ n) = n := by
rw [X_pow_eq, order_monomial_of_ne_zero]
exact one_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_X_pow | The order of the formal power series `X^n` is `n`. |
@[simp]
divXPowOrder_X :
divXPowOrder X = (1 : R⟦X⟧) := by
ext n
simp [coeff_X]
@[deprecated (since := "2025-04-15")] alias divided_by_X_pow_order_of_X_eq_one := divXPowOrder_X | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | divXPowOrder_X | Dividing `X` by the maximal power of `X` dividing it leaves `1`. |
order_mul (φ ψ : R⟦X⟧) : order (φ * ψ) = order φ + order ψ := by
apply le_antisymm _ (le_order_mul _ _)
by_cases h : φ = 0 ∨ ψ = 0
· rcases h with h | h <;> simp [h]
· push_neg at h
rw [← coe_toNat_order h.1, ← coe_toNat_order h.2, ← ENat.coe_add]
apply order_le
rw [coeff_mul, Finset.sum_eq_single_of_mem ⟨φ.order.toNat, ψ.order.toNat⟩ (by simp)]
· exact mul_ne_zero (coeff_order h.1) (coeff_order h.2)
· intro ij hij h
rcases trichotomy_of_add_eq_add (mem_antidiagonal.mp hij) with h' | h' | h'
· exact False.elim (h (by simp [Prod.ext_iff, h'.1, h'.2]))
· rw [coeff_of_lt_order_toNat ij.1 h', zero_mul]
· rw [coeff_of_lt_order_toNat ij.2 h', mul_zero] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_mul | The order of the product of two formal power series over an integral domain
is the sum of their orders. |
order_pow [Nontrivial R] (φ : R⟦X⟧) (n : ℕ) :
order (φ ^ n) = n • order φ := by
rcases subsingleton_or_nontrivial R with hR | hR
· simp only [Subsingleton.eq_zero φ, order_zero, nsmul_eq_mul]
by_cases hn : n = 0
· simp [hn, pow_zero]
· simp [zero_pow hn, ENat.mul_top', if_neg hn]
induction n with
| zero => simp
| succ n hn =>
simp only [add_smul, one_smul, pow_succ, order_mul, hn] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_pow | null |
order_prod {R : Type*} [CommSemiring R] [NoZeroDivisors R] [Nontrivial R] {ι : Type*}
(φ : ι → R⟦X⟧) (s : Finset ι) : (∏ i ∈ s, φ i).order = ∑ i ∈ s, (φ i).order := by
induction s using Finset.cons_induction with
| empty => simp
| cons a s ha ih => rw [Finset.sum_cons ha, Finset.prod_cons ha, order_mul, ih] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | order_prod | null |
divXPowOrder_mul_divXPowOrder {f g : R⟦X⟧} :
divXPowOrder f * divXPowOrder g = divXPowOrder (f * g) := by
by_cases h : f = 0 ∨ g = 0
· rcases h with (h | h) <;> simp [h]
push_neg at h
apply X_pow_mul_cancel (k := f.order.toNat + g.order.toNat)
calc
X ^ (f.order.toNat + g.order.toNat) * (f.divXPowOrder * g.divXPowOrder)
_ = (X ^ f.order.toNat * f.divXPowOrder) * (X ^ g.order.toNat * g.divXPowOrder) := by
conv_rhs =>
rw [mul_assoc, X_pow_mul, X_pow_mul, ← mul_assoc, mul_assoc, ← pow_add]
rw [X_pow_mul, add_comm]
_ = f * g := by
simp [X_pow_order_mul_divXPowOrder]
_ = X ^ ((f * g).order.toNat) * (f * g).divXPowOrder := by
simp [X_pow_order_mul_divXPowOrder]
_ = X ^ (f.order.toNat + g.order.toNat) * (f * g).divXPowOrder := by
rw [order_mul, ENat.toNat_add (order_eq_top.not.mpr h.1) (order_eq_top.not.mpr h.2)]
@[deprecated (since := "2025-04-15")] alias divided_by_X_pow_orderMul :=
divXPowOrder_mul_divXPowOrder | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/Order.lean | divXPowOrder_mul_divXPowOrder | The operation of dividing a power series by the largest possible power of `X`
preserves multiplication. |
@[scoped instance]
instT0Space [T0Space R] : T0Space (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instT0Space | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instT0Space | The pointwise topology on `PowerSeries` -/
scoped instance : TopologicalSpace (PowerSeries R) :=
Pi.topologicalSpace
/-- Separation of the topology on `PowerSeries` |
@[scoped instance]
instT2Space [T2Space R] : T2Space (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instT2Space | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instT2Space | `PowerSeries` on a `T2Space` form a `T2Space` |
continuous_coeff [Semiring R] (d : ℕ) : Continuous (PowerSeries.coeff (R := R) d) :=
continuous_pi_iff.mp continuous_id (Finsupp.single () d) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | continuous_coeff | Coefficients are continuous |
continuous_constantCoeff [Semiring R] : Continuous (constantCoeff (R := R)) :=
coeff_zero_eq_constantCoeff (R := R) ▸ continuous_coeff R 0 | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | continuous_constantCoeff | The constant coefficient is continuous |
tendsto_iff_coeff_tendsto [Semiring R] {ι : Type*}
(f : ι → PowerSeries R) (u : Filter ι) (g : PowerSeries R) :
Tendsto f u (nhds g) ↔
∀ d : ℕ, Tendsto (fun i => coeff d (f i)) u (nhds (coeff d g)) := by
rw [MvPowerSeries.WithPiTopology.tendsto_iff_coeff_tendsto]
apply (Finsupp.LinearEquiv.finsuppUnique ℕ ℕ Unit).toEquiv.forall_congr
intro d
simp only [LinearEquiv.coe_toEquiv, Finsupp.LinearEquiv.finsuppUnique_apply,
PUnit.default_eq_unit, coeff]
apply iff_of_eq
congr
· ext _; congr; ext; simp
· ext; simp | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | tendsto_iff_coeff_tendsto | A family of power series converges iff it converges coefficientwise |
tendsto_trunc_atTop [CommSemiring R] (f : R⟦X⟧) :
Tendsto (fun d ↦ (trunc d f : R⟦X⟧)) atTop (𝓝 f) := by
rw [tendsto_iff_coeff_tendsto]
intro d
exact tendsto_atTop_of_eventually_const fun n (hdn : d < n) ↦ (by simp [coeff_trunc, hdn]) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | tendsto_trunc_atTop | null |
denseRange_toPowerSeries [CommSemiring R] :
DenseRange (Polynomial.toPowerSeries (R := R)) := fun f =>
mem_closure_of_tendsto (tendsto_trunc_atTop R f) <| .of_forall fun _ ↦ Set.mem_range_self _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | denseRange_toPowerSeries | The inclusion of polynomials into power series has dense image |
@[scoped instance]
instIsTopologicalSemiring [Semiring R] [IsTopologicalSemiring R] :
IsTopologicalSemiring (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instIsTopologicalSemiring Unit R | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instIsTopologicalSemiring | The semiring topology on `PowerSeries` of a topological semiring |
@[scoped instance]
instIsTopologicalRing [Ring R] [IsTopologicalRing R] :
IsTopologicalRing (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instIsTopologicalRing Unit R | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instIsTopologicalRing | The ring topology on `PowerSeries` of a topological ring |
hasSum_iff_hasSum_coeff {g : R⟦X⟧} :
HasSum f g ↔ ∀ d, HasSum (fun i ↦ coeff d (f i)) (coeff d g) := by
simp_rw [HasSum, ← map_sum]
apply tendsto_iff_coeff_tendsto | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | hasSum_iff_hasSum_coeff | null |
summable_iff_summable_coeff :
Summable f ↔ ∀ d : ℕ, Summable (fun i ↦ coeff d (f i)) := by
simp_rw [Summable, hasSum_iff_hasSum_coeff]
constructor
· rintro ⟨a, h⟩ n
exact ⟨coeff n a, h n⟩
· intro h
choose a h using h
exact ⟨mk a, by simpa using h⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | summable_iff_summable_coeff | null |
summable_of_tendsto_order_atTop_nhds_top [LinearOrder ι] [LocallyFiniteOrderBot ι]
(h : Tendsto (fun i ↦ (f i).order) atTop (𝓝 ⊤)) : Summable f := by
rcases isEmpty_or_nonempty ι with hempty | hempty
· apply summable_empty
rw [summable_iff_summable_coeff]
intro n
simp_rw [ENat.tendsto_nhds_top_iff_natCast_lt, Filter.eventually_atTop] at h
obtain ⟨i, hi⟩ := h n
refine summable_of_finite_support <| (Set.finite_Iic i).subset ?_
simp_rw [Function.support_subset_iff, Set.mem_Iic]
intro k hk
contrapose! hk
exact coeff_of_lt_order _ <| by simpa using (hi k hk.le) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | summable_of_tendsto_order_atTop_nhds_top | A family of `PowerSeries` is summable if their order tends to infinity. |
uniformContinuous_coeff [Semiring R] (d : ℕ) :
UniformContinuous fun f : PowerSeries R ↦ coeff d f :=
uniformContinuous_pi.mp uniformContinuous_id (Finsupp.single () d) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | uniformContinuous_coeff | The product uniformity on `PowerSeries` -/
scoped instance : UniformSpace (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instUniformSpace
/-- Coefficients are uniformly continuous |
@[scoped instance]
instCompleteSpace [CompleteSpace R] :
CompleteSpace (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instCompleteSpace | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instCompleteSpace | Completeness of the uniform structure on `PowerSeries` |
@[scoped instance]
instIsUniformAddGroup [AddGroup R] [IsUniformAddGroup R] :
IsUniformAddGroup (PowerSeries R) :=
MvPowerSeries.WithPiTopology.instIsUniformAddGroup
@[deprecated (since := "2025-03-27")] alias instUniformAddGroup := instIsUniformAddGroup | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | instIsUniformAddGroup | The `IsUniformAddGroup` structure on `PowerSeries` of a `IsUniformAddGroup` |
continuous_C [Semiring R] : Continuous (C (R := R)) :=
MvPowerSeries.WithPiTopology.continuous_C | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | continuous_C | null |
isTopologicallyNilpotent_of_constantCoeff_isNilpotent [CommSemiring R]
{f : PowerSeries R} (hf : IsNilpotent (constantCoeff (R := R) f)) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) :=
MvPowerSeries.WithPiTopology.isTopologicallyNilpotent_of_constantCoeff_isNilpotent hf | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | isTopologicallyNilpotent_of_constantCoeff_isNilpotent | null |
isTopologicallyNilpotent_of_constantCoeff_zero [CommSemiring R]
{f : PowerSeries R} (hf : constantCoeff (R := R) f = 0) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) :=
MvPowerSeries.WithPiTopology.isTopologicallyNilpotent_of_constantCoeff_zero hf | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | isTopologicallyNilpotent_of_constantCoeff_zero | null |
isTopologicallyNilpotent_iff_constantCoeff_isNilpotent
[CommRing R] [DiscreteTopology R] (f : PowerSeries R) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) ↔
IsNilpotent (constantCoeff f) :=
MvPowerSeries.WithPiTopology.isTopologicallyNilpotent_iff_constantCoeff_isNilpotent f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | isTopologicallyNilpotent_iff_constantCoeff_isNilpotent | Assuming the base ring has a discrete topology, the powers of a `PowerSeries` converge to 0
iff its constant coefficient is nilpotent.
[N. Bourbaki, *Algebra {II}*, Chapter 4, §4, n°2, corollary of prop. 3][bourbaki1981] |
hasSum_of_monomials_self (f : PowerSeries R) :
HasSum (fun d : ℕ => monomial d (coeff d f)) f := by
rw [← (Finsupp.LinearEquiv.finsuppUnique ℕ ℕ Unit).toEquiv.hasSum_iff]
convert MvPowerSeries.WithPiTopology.hasSum_of_monomials_self f
simp only [LinearEquiv.coe_toEquiv, comp_apply, monomial, coeff,
Finsupp.LinearEquiv.finsuppUnique_apply, PUnit.default_eq_unit]
congr
all_goals { ext; simp } | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | hasSum_of_monomials_self | A power series is the sum (in the sense of summable families) of its monomials |
as_tsum [T2Space R] (f : PowerSeries R) :
f = tsum fun d : ℕ => monomial d (coeff d f) :=
(HasSum.tsum_eq (hasSum_of_monomials_self f)).symm | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.PiTopology",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.PowerSeries.Order",
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.LinearAlgebra.Finsupp.Pi"
] | Mathlib/RingTheory/PowerSeries/PiTopology.lean | as_tsum | If the coefficient space is T2, then the power series is `tsum` of its monomials |
IsRestricted (f : PowerSeries R) :=
Tendsto (fun (i : ℕ) ↦ (norm (coeff i f)) * c ^ i) atTop (𝓝 0) | def | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | IsRestricted | A power series over `R` is restricted of paramerter `c` if we have
`‖coeff R i f‖ * c ^ i → 0`. |
isRestricted_iff {f : PowerSeries R} : IsRestricted c f ↔
∀ ε, 0 < ε → ∃ N, ∀ n, N ≤ n → ‖‖(coeff n) f‖ * c ^ n‖ < ε := by
simp [IsRestricted, NormedAddCommGroup.tendsto_atTop] | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | isRestricted_iff | null |
isRestricted_iff_abs (f : PowerSeries R) : IsRestricted c f ↔ IsRestricted |c| f := by
simp [isRestricted_iff] | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | isRestricted_iff_abs | null |
zero : IsRestricted c (0 : PowerSeries R) := by
simp [IsRestricted] | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | zero | null |
one : IsRestricted c (1 : PowerSeries R) := by
simp only [isRestricted_iff, coeff_one, norm_mul, norm_pow, Real.norm_eq_abs]
refine fun _ _ ↦ ⟨1, fun n hn ↦ ?_ ⟩
split
· omega
· simpa | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | one | null |
monomial (n : ℕ) (a : R) : IsRestricted c (monomial n a) := by
simp only [monomial_eq_mk, isRestricted_iff, coeff_mk, norm_mul, norm_pow,
Real.norm_eq_abs, abs_norm]
refine fun _ _ ↦ ⟨n + 1, fun _ _ ↦ ?_⟩
split
· omega
· simpa | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | monomial | null |
C (a : R) : IsRestricted c (C a) := by
simpa [monomial_zero_eq_C_apply] using monomial c 0 a | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | C | null |
add {f g : PowerSeries R} (hf : IsRestricted c f) (hg : IsRestricted c g) :
IsRestricted c (f + g) := by
simp only [isRestricted_iff, map_add, norm_mul, norm_pow, Real.norm_eq_abs] at ⊢ hf hg
intro ε hε
obtain ⟨fN, hfN⟩ := hf (ε / 2) (by positivity)
obtain ⟨gN, hgN⟩ := hg (ε / 2) (by positivity)
simp only [abs_norm] at hfN hgN ⊢
refine ⟨max fN gN, fun n hn ↦ ?_ ⟩
calc _ ≤ ‖(coeff n) f‖ * |c| ^ n + ‖(coeff n) g‖ * |c| ^ n := by grw [norm_add_le, add_mul]
_ < ε / 2 + ε / 2 := by gcongr <;> grind
_ = ε := by ring | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | add | null |
neg {f : PowerSeries R} (hf : IsRestricted c f) : IsRestricted c (-f) := by
simpa [isRestricted_iff] using hf | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | neg | null |
smul {f : PowerSeries R} (hf : IsRestricted c f) (r : R) : IsRestricted c (r • f) := by
if h : r = 0 then (simpa [h] using zero c) else
simp_rw [isRestricted_iff, norm_mul, norm_pow, Real.norm_eq_abs, abs_norm] at ⊢ hf
intro ε _
obtain ⟨n, hn⟩ := hf (ε / ‖r‖) (by positivity)
refine ⟨n, fun N hN ↦ ?_⟩
calc _ ≤ ‖r‖ * ‖(coeff N) f‖ * |c| ^ N :=
mul_le_mul_of_nonneg (norm_mul_le _ _) (by simp) (by simp) (by simp)
_ < ‖r‖ * (ε / ‖r‖) := by
rw [mul_assoc]; aesop
_ = ε := mul_div_cancel₀ _ (by aesop) | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | smul | null |
convergenceSet (f : PowerSeries R) : Set ℝ := {‖coeff i f‖ * c^i | i : ℕ}
open Finset in | def | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | convergenceSet | The set of `‖coeff R i f‖ * c ^ i` for a given power series `f` and parameter `c`. |
convergenceSet_BddAbove {f : PowerSeries R} (hf : IsRestricted c f) :
BddAbove (convergenceSet c f) := by
simp_rw [isRestricted_iff] at hf
obtain ⟨N, hf⟩ := by simpa using (hf 1)
rw [bddAbove_def, convergenceSet]
use max 1 (max' (image (fun i ↦ ‖coeff i f‖ * c ^ i) (range (N + 1))) (by simp))
simp only [Set.mem_setOf_eq, le_sup_iff, forall_exists_index, forall_apply_eq_imp_iff]
intro i
rcases le_total i N with h | h
· right
apply le_max'
simp only [mem_image, mem_range]
exact ⟨i, by omega, rfl⟩
· left
calc _ ≤ ‖(coeff i) f‖ * |c ^ i| := by bound
_ ≤ 1 := by simpa using (hf i h).le
variable [IsUltrametricDist R]
open IsUltrametricDist | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | convergenceSet_BddAbove | null |
mul {f g : PowerSeries R} (hf : IsRestricted c f) (hg : IsRestricted c g) :
IsRestricted c (f * g) := by
obtain ⟨a, ha, fBound1⟩ := (bddAbove_iff_exists_ge 1).mp (convergenceSet_BddAbove _
((isRestricted_iff_abs c f).mp hf))
obtain ⟨b, hb, gBound1⟩ := (bddAbove_iff_exists_ge 1).mp (convergenceSet_BddAbove _
((isRestricted_iff_abs c g).mp hg))
simp only [convergenceSet, Set.mem_setOf_eq, forall_exists_index, forall_apply_eq_imp_iff]
at fBound1 gBound1
simp only [isRestricted_iff, norm_mul, norm_pow, Real.norm_eq_abs, abs_norm,
PowerSeries.coeff_mul] at ⊢ hf hg
intro ε hε
obtain ⟨Nf, fBound2⟩ := (hf (ε / (max a b))) (by positivity)
obtain ⟨Ng, gBound2⟩ := (hg (ε / (max a b))) (by positivity)
refine ⟨2 * max Nf Ng, fun n hn ↦ ?_⟩
obtain ⟨⟨fst, snd⟩, hi, ultrametric⟩ := exists_norm_finset_sum_le (Finset.antidiagonal n)
(fun a ↦ (coeff a.1) f * (coeff a.2) g)
obtain ⟨rfl⟩ := by simpa using hi (⟨(0, n), by simp⟩)
calc _ ≤ ‖(coeff fst) f * (coeff snd) g‖ * |c| ^ (fst + snd) := by bound
_ ≤ ‖(coeff fst) f‖ * |c| ^ fst * (‖(coeff snd) g‖ * |c| ^ snd) := by
grw [norm_mul_le]; grind
have : max Nf Ng ≤ fst ∨ max Nf Ng ≤ snd := by omega
rcases this with this | this
· calc _ < ε / max a b * b := by
grw [gBound1 snd]
gcongr
exact fBound2 fst (by omega)
_ ≤ ε := by
rw [div_mul_comm, mul_le_iff_le_one_left ‹_›]
bound
· calc _ < a * (ε / max a b) := by
grw [fBound1 fst]
gcongr
exact gBound2 snd (by omega)
_ ≤ ε := by
rw [mul_div_left_comm, mul_le_iff_le_one_right ‹_›]
bound | lemma | RingTheory | [
"Mathlib.Analysis.Normed.Group.Ultra",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.Tactic.Bound"
] | Mathlib/RingTheory/PowerSeries/Restricted.lean | mul | null |
HasSubst (a : MvPowerSeries τ S) : Prop :=
IsNilpotent (MvPowerSeries.constantCoeff a) | abbrev | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst | (Possibly multivariate) power series which can be substituted in a `PowerSeries`. |
hasSubst_iff {a : MvPowerSeries τ S} :
HasSubst a ↔ MvPowerSeries.HasSubst (Function.const Unit a) :=
⟨fun ha ↦ MvPowerSeries.hasSubst_of_constantCoeff_nilpotent (Function.const Unit ha),
fun ha ↦ (ha.const_coeff ())⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | hasSubst_iff | null |
HasSubst.const {a : MvPowerSeries τ S} (ha : HasSubst a) :
MvPowerSeries.HasSubst (fun () ↦ a) :=
hasSubst_iff.mp ha | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.const | null |
hasSubst_iff_hasEval_of_discreteTopology
[TopologicalSpace S] [DiscreteTopology S] {a : MvPowerSeries τ S} :
HasSubst a ↔ PowerSeries.HasEval a := by
rw [hasSubst_iff, MvPowerSeries.hasSubst_iff_hasEval_of_discreteTopology, hasEval_iff,
Function.const_def] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | hasSubst_iff_hasEval_of_discreteTopology | null |
HasSubst.hasEval [TopologicalSpace S] {a : MvPowerSeries τ S} (ha : HasSubst a) :
HasEval a := by
rw [hasEval_iff]
apply MvPowerSeries.HasSubst.hasEval
simpa [hasSubst_iff] using ha | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.hasEval | null |
HasSubst.of_constantCoeff_zero {a : MvPowerSeries τ S}
(ha : MvPowerSeries.constantCoeff a = 0) : HasSubst a := by
simp [HasSubst, ha] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.of_constantCoeff_zero | null |
HasSubst.of_constantCoeff_zero' {a : PowerSeries S}
(ha : PowerSeries.constantCoeff a = 0) : HasSubst a :=
HasSubst.of_constantCoeff_zero ha | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.of_constantCoeff_zero' | A variant of `HasSubst.of_constantCoeff_zero` for `PowerSeries`
to avoid the expansion of `Unit`. |
protected HasSubst.X (t : τ) :
HasSubst (MvPowerSeries.X t : MvPowerSeries τ S) := by
simp [HasSubst] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.X | null |
protected HasSubst.X' : HasSubst (X : R⟦X⟧) :=
HasSubst.X _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.X' | The univariate `X : R⟦X⟧` can be substituted in power series
This lemma is added because `simp` doesn't find it from `HasSubst.X`. |
protected HasSubst.X_pow {n : ℕ} (hn : n ≠ 0) : HasSubst (X ^ n : R⟦X⟧) :=
HasSubst.of_constantCoeff_zero' (by simp [hn]) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.X_pow | null |
protected HasSubst.monomial {n : τ →₀ ℕ} (hn : n ≠ 0) (s : S) :
HasSubst (MvPowerSeries.monomial n s) := by
classical
apply HasSubst.of_constantCoeff_zero
rw [← MvPowerSeries.coeff_zero_eq_constantCoeff, MvPowerSeries.coeff_monomial,
if_neg hn.symm] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.monomial | null |
protected HasSubst.monomial' {n : ℕ} (hn : n ≠ 0) (s : S) :
HasSubst (monomial n s) :=
HasSubst.monomial (Finsupp.single_ne_zero.mpr hn) s | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.monomial' | A variant of `HasSubst.monomial` to avoid the expansion of `Unit`. |
HasSubst.zero : HasSubst (0 : MvPowerSeries τ R) := by
rw [hasSubst_iff]
exact MvPowerSeries.HasSubst.zero | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.zero | null |
HasSubst.zero' : HasSubst (0 : PowerSeries R) :=
PowerSeries.HasSubst.zero
variable {f g : MvPowerSeries τ R} | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.zero' | A variant of `HasSubst.zero` to avoid the expansion of `Unit`. |
HasSubst.add (hf : HasSubst f) (hg : HasSubst g) :
HasSubst (f + g) :=
(Commute.all _ _).isNilpotent_add hf hg | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.add | null |
HasSubst.mul_left (hf : HasSubst f) :
HasSubst (f * g) := by
simp only [HasSubst, map_mul]
exact (Commute.all _ _).isNilpotent_mul_right hf | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.mul_left | null |
HasSubst.mul_right (hf : HasSubst f) :
HasSubst (g * f) := by
simp only [HasSubst, map_mul]
exact (Commute.all _ _).isNilpotent_mul_left hf | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.mul_right | null |
HasSubst.smul (r : MvPowerSeries τ S) {a : MvPowerSeries τ S} (ha : HasSubst a) :
HasSubst (r • a) :=
ha.mul_right | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.smul | null |
noncomputable HasSubst.ideal : Ideal (MvPowerSeries τ S) where
carrier := setOf HasSubst
add_mem' := HasSubst.add
zero_mem' := HasSubst.zero
smul_mem' := HasSubst.smul | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.ideal | Families of `PowerSeries` that can be substituted, as an `Ideal`. |
HasSubst.smul' (a : A) (hf : HasSubst f) :
HasSubst (a • f) := by
simp only [HasSubst, MvPowerSeries.constantCoeff_smul]
exact IsNilpotent.smul hf _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.smul' | A more general version of `HasSubst.smul`. |
HasSubst.smul_X (a : A) (t : τ) :
HasSubst (a • (MvPowerSeries.X t) : MvPowerSeries τ R) :=
(HasSubst.X t).smul' _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.smul_X | null |
HasSubst.smul_X' (a : A) : HasSubst (a • X : R⟦X⟧) :=
HasSubst.X'.smul' _
variable {υ : Type*} {T : Type*} [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | HasSubst.smul_X' | null |
noncomputable subst (a : MvPowerSeries τ S) (f : PowerSeries R) :
MvPowerSeries τ S :=
MvPowerSeries.subst (fun _ ↦ a) f
variable {a : MvPowerSeries τ S} {b : S⟦X⟧} | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst | Substitution of power series into a power series. |
noncomputable substAlgHom (ha : HasSubst a) :
PowerSeries R →ₐ[R] MvPowerSeries τ S :=
MvPowerSeries.substAlgHom ha.const | def | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom | Substitution of power series into a power series, as an `AlgHom`. |
coe_substAlgHom (ha : HasSubst a) :
⇑(substAlgHom ha) = subst (R := R) a :=
MvPowerSeries.coe_substAlgHom ha.const
attribute [local instance] DiscreteTopology.instContinuousSMul in | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | coe_substAlgHom | null |
substAlgHom_eq_aeval
[UniformSpace R] [DiscreteUniformity R] [UniformSpace S] [DiscreteUniformity S]
(ha : HasSubst a) :
(substAlgHom ha : R⟦X⟧ →ₐ[R] MvPowerSeries τ S) = PowerSeries.aeval ha.hasEval := by
ext1 f
simpa [substAlgHom] using congr_fun (MvPowerSeries.substAlgHom_eq_aeval ha.const) f | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | substAlgHom_eq_aeval | Rewrite `PowerSeries.substAlgHom` as `PowerSeries.aeval`.
Its use is discouraged because it introduces a topology and might lead
into awkward comparisons. |
subst_add (ha : HasSubst a) (f g : PowerSeries R) :
subst a (f + g) = subst a f + subst a g := by
rw [← coe_substAlgHom ha, map_add] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_add | null |
subst_pow (ha : HasSubst a) (f : PowerSeries R) (n : ℕ) :
subst a (f ^ n) = (subst a f) ^ n := by
rw [← coe_substAlgHom ha, map_pow] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_pow | null |
subst_mul (ha : HasSubst a) (f g : PowerSeries R) :
subst a (f * g) = subst a f * subst a g := by
rw [← coe_substAlgHom ha, map_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_mul | null |
subst_smul [Algebra A S] [IsScalarTower A R S]
(ha : HasSubst a) (r : A) (f : PowerSeries R) :
subst a (r • f) = r • (subst a f) := by
rw [← coe_substAlgHom ha, AlgHom.map_smul_of_tower] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | subst_smul | null |
coeff_subst_finite (ha : HasSubst a) (f : PowerSeries R) (e : τ →₀ ℕ) :
Set.Finite (fun (d : ℕ) ↦ coeff d f • MvPowerSeries.coeff e (a ^ d)).support := by
convert (MvPowerSeries.coeff_subst_finite ha.const f e).image
(Finsupp.LinearEquiv.finsuppUnique ℕ ℕ Unit).toEquiv
rw [← Equiv.preimage_eq_iff_eq_image, ← Function.support_comp_eq_preimage]
apply congr_arg
rw [← Equiv.eq_comp_symm]
ext
simp [coeff] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | coeff_subst_finite | null |
coeff_subst_finite' (hb : HasSubst b) (f : PowerSeries R) (e : ℕ) :
Set.Finite (fun (d : ℕ) ↦ coeff d f • (PowerSeries.coeff e (b ^ d))).support :=
coeff_subst_finite hb f _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | coeff_subst_finite' | null |
coeff_subst (ha : HasSubst a) (f : PowerSeries R) (e : τ →₀ ℕ) :
MvPowerSeries.coeff e (subst a f) =
finsum (fun (d : ℕ) ↦
coeff d f • (MvPowerSeries.coeff e (a ^ d))) := by
rw [subst, MvPowerSeries.coeff_subst ha.const f e, ← finsum_comp_equiv
(Finsupp.LinearEquiv.finsuppUnique ℕ ℕ Unit).toEquiv.symm]
apply finsum_congr
intro
congr <;> simp | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | coeff_subst | null |
coeff_subst' {b : S⟦X⟧} (hb : HasSubst b) (f : R⟦X⟧) (e : ℕ) :
coeff e (f.subst b) =
finsum (fun (d : ℕ) ↦
coeff d f • PowerSeries.coeff e (b ^ d)) := by
simp [PowerSeries.coeff, coeff_subst hb] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | coeff_subst' | null |
constantCoeff_subst (ha : HasSubst a) (f : PowerSeries R) :
MvPowerSeries.constantCoeff (subst a f) =
finsum (fun d ↦ coeff d f • MvPowerSeries.constantCoeff (a ^ d)) := by
simp only [← MvPowerSeries.coeff_zero_eq_constantCoeff_apply, coeff_subst ha f 0] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Substitution",
"Mathlib.RingTheory.PowerSeries.Evaluation"
] | Mathlib/RingTheory/PowerSeries/Substitution.lean | constantCoeff_subst | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.