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 ⌀ |
|---|---|---|---|---|---|---|
mem_nonZeroDivisorsRight_of_constantCoeff {φ : MvPowerSeries σ R}
(hφ : constantCoeff φ ∈ nonZeroDivisorsRight R) :
φ ∈ nonZeroDivisorsRight (MvPowerSeries σ R) := by
classical
intro x hx
ext d
apply WellFoundedLT.induction d
intro e he
rw [map_zero, ← mul_right_mem_nonZeroDivisorsRight_eq_zero_iff hφ,
← map_zero (f := coeff e), ← hx]
convert (coeff_mul e x φ).symm
rw [Finset.sum_eq_single (e, 0), coeff_zero_eq_constantCoeff]
· rintro ⟨u, _⟩ huv _
suffices u < e by simp only [he u this, zero_mul, map_zero]
apply lt_of_le_of_ne
· simp only [← mem_antidiagonal.mp huv, le_add_iff_nonneg_right, zero_le]
· rintro rfl
simp_all
· simp only [mem_antidiagonal, add_zero, not_true_eq_false, coeff_zero_eq_constantCoeff,
false_implies] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | mem_nonZeroDivisorsRight_of_constantCoeff | null |
mem_nonZeroDivisorsLeft_of_constantCoeff {φ : MvPowerSeries σ R}
(hφ : constantCoeff φ ∈ nonZeroDivisorsLeft R) :
φ ∈ nonZeroDivisorsLeft (MvPowerSeries σ R) := by
classical
intro x hx
ext d
apply WellFoundedLT.induction d
intro e he
rw [map_zero, ← mul_left_mem_nonZeroDivisorsLeft_eq_zero_iff hφ,
← map_zero (f := coeff e), ← hx]
convert (coeff_mul e φ x).symm
rw [Finset.sum_eq_single (0, e), coeff_zero_eq_constantCoeff]
· rintro ⟨_, u⟩ huv _
suffices u < e by simp only [he u this, mul_zero, map_zero]
apply lt_of_le_of_ne
· simp only [← mem_antidiagonal.mp huv, le_add_iff_nonneg_left, zero_le]
· rintro rfl
simp_all
· simp only [mem_antidiagonal, zero_add, not_true_eq_false, coeff_zero_eq_constantCoeff,
false_implies] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | mem_nonZeroDivisorsLeft_of_constantCoeff | null |
mem_nonZeroDivisors_of_constantCoeff {φ : MvPowerSeries σ R}
(hφ : constantCoeff φ ∈ R⁰) :
φ ∈ (MvPowerSeries σ R)⁰ :=
⟨mem_nonZeroDivisorsLeft_of_constantCoeff hφ.1, mem_nonZeroDivisorsRight_of_constantCoeff hφ.2⟩ | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | mem_nonZeroDivisors_of_constantCoeff | A multivariate power series is not a zero divisor
when its constant coefficient is not a zero divisor |
monomial_mem_nonzeroDivisorsLeft {n : σ →₀ ℕ} {r} :
monomial n r ∈ nonZeroDivisorsLeft (MvPowerSeries σ R) ↔ r ∈ nonZeroDivisorsLeft R := by
constructor
· intro H s hrs
have := H (C s) (by rw [← monomial_zero_eq_C, monomial_mul_monomial]; ext; simp [hrs])
simpa using congr(coeff 0 $(this))
· intro H p hrp
ext i
have := congr(coeff (i + n) $hrp)
rw [coeff_monomial_mul, if_pos le_add_self, add_tsub_cancel_right] at this
simpa using H _ this | lemma | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | monomial_mem_nonzeroDivisorsLeft | null |
monomial_mem_nonzeroDivisorsRight {n : σ →₀ ℕ} {r} :
monomial n r ∈ nonZeroDivisorsRight (MvPowerSeries σ R) ↔ r ∈ nonZeroDivisorsRight R := by
constructor
· intro H s hrs
have := H (C s) (by rw [← monomial_zero_eq_C, monomial_mul_monomial]; ext; simp [hrs])
simpa using congr(coeff 0 $(this))
· intro H p hrp
ext i
have := congr(coeff (i + n) $hrp)
rw [coeff_mul_monomial, if_pos le_add_self, add_tsub_cancel_right] at this
simpa using H _ this | lemma | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | monomial_mem_nonzeroDivisorsRight | null |
monomial_mem_nonzeroDivisors {n : σ →₀ ℕ} {r} :
monomial n r ∈ (MvPowerSeries σ R)⁰ ↔ r ∈ R⁰ :=
monomial_mem_nonzeroDivisorsLeft.and monomial_mem_nonzeroDivisorsRight | lemma | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | monomial_mem_nonzeroDivisors | null |
X_mem_nonzeroDivisors {i : σ} :
X i ∈ (MvPowerSeries σ R)⁰ := by
rw [X, monomial_mem_nonzeroDivisors]
exact Submonoid.one_mem R⁰ | lemma | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | X_mem_nonzeroDivisors | null |
weightedOrder_mul (w : σ → ℕ) (f g : MvPowerSeries σ R) :
(f * g).weightedOrder w = f.weightedOrder w + g.weightedOrder w := by
apply le_antisymm _ (le_weightedOrder_mul w)
by_cases hf : f.weightedOrder w < ⊤
· by_cases hg : g.weightedOrder w < ⊤
· let p := (f.weightedOrder w).toNat
have hp : p = f.weightedOrder w := by
simpa only [p, ENat.coe_toNat_eq_self, ← lt_top_iff_ne_top]
let q := (g.weightedOrder w).toNat
have hq : q = g.weightedOrder w := by
simpa only [q, ENat.coe_toNat_eq_self, ← lt_top_iff_ne_top]
have : f.weightedHomogeneousComponent w p * g.weightedHomogeneousComponent w q ≠ 0 := by
simp only [ne_eq, mul_eq_zero]
intro H
rcases H with H | H <;>
· refine weightedHomogeneousComponent_of_weightedOrder ?_ H
simp only [ENat.coe_toNat_eq_self, ne_eq, weightedOrder_eq_top_iff, p, q]
rw [← ne_eq, ne_zero_iff_weightedOrder_finite w]
exact ENat.coe_toNat (ne_top_of_lt (by simpa))
rw [← weightedHomogeneousComponent_mul_of_le_weightedOrder
(le_of_eq hp) (le_of_eq hq)] at this
rw [← hp, ← hq, ← Nat.cast_add, ← not_lt]
intro H
apply this
apply weightedHomogeneousComponent_of_lt_weightedOrder_eq_zero H
· rw [not_lt_top_iff] at hg
simp [hg]
· rw [not_lt_top_iff] at hf
simp [hf] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | weightedOrder_mul | null |
weightedOrder_prod {R : Type*} [CommSemiring R] [NoZeroDivisors R] [Nontrivial R]
{ι : Type*} (w : σ → ℕ) (f : ι → MvPowerSeries σ R) (s : Finset ι) :
(∏ i ∈ s, f i).weightedOrder w = ∑ i ∈ s, (f i).weightedOrder w:= by
induction s using Finset.cons_induction with
| empty => simp
| cons a s ha ih => rw [Finset.sum_cons ha, Finset.prod_cons ha, weightedOrder_mul, ih] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | weightedOrder_prod | null |
order_mul (f g : MvPowerSeries σ R) :
(f * g).order = f.order + g.order :=
weightedOrder_mul _ f g | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | order_mul | null |
order_prod {R : Type*} [CommSemiring R] [NoZeroDivisors R] [Nontrivial R]
{ι : Type*} (f : ι → MvPowerSeries σ R) (s : Finset ι) :
(∏ i ∈ s, f i).order = ∑ i ∈ s, (f i).order := weightedOrder_prod _ _ _ | theorem | RingTheory | [
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.RingTheory.MvPowerSeries.LexOrder",
"Mathlib.RingTheory.MvPowerSeries.Order"
] | Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean | order_prod | null |
ne_zero_iff_exists_coeff_ne_zero_and_weight :
f ≠ 0 ↔ (∃ n : ℕ, ∃ d : σ →₀ ℕ, coeff d f ≠ 0 ∧ weight w d = n) := by
refine not_iff_not.mp ?_
simp only [ne_eq, not_not, not_exists, not_and, forall_apply_eq_imp_iff₂, imp_false]
exact MvPowerSeries.ext_iff | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | ne_zero_iff_exists_coeff_ne_zero_and_weight | null |
weightedOrder (f : MvPowerSeries σ R) : ℕ∞ := by
classical
exact dite (f = 0) (fun _ => ⊤) fun h =>
Nat.find ((ne_zero_iff_exists_coeff_ne_zero_and_weight w).mp h)
@[simp] theorem weightedOrder_zero : (0 : MvPowerSeries σ R).weightedOrder w = ⊤ := by
rw [weightedOrder, dif_pos rfl] | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder | The weighted order of a mv_power_series |
ne_zero_iff_weightedOrder_finite :
f ≠ 0 ↔ (f.weightedOrder w).toNat = f.weightedOrder w := by
simp only [weightedOrder, ne_eq, coe_toNat_eq_self, dite_eq_left_iff,
ENat.coe_ne_top, imp_false, not_not] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | ne_zero_iff_weightedOrder_finite | null |
@[simp]
weightedOrder_eq_top_iff :
f.weightedOrder w = ⊤ ↔ f = 0 := by
rw [← not_iff_not, ← ne_eq, ← ne_eq, ne_zero_iff_weightedOrder_finite w, coe_toNat_eq_self] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_eq_top_iff | The `0` power series is the unique power series with infinite order. |
exists_coeff_ne_zero_and_weightedOrder
(h : (toNat (f.weightedOrder w) : ℕ∞) = f.weightedOrder w) :
∃ d, coeff d f ≠ 0 ∧ weight w d = f.weightedOrder w := by
classical
simp_rw [weightedOrder, dif_neg ((ne_zero_iff_weightedOrder_finite w).mpr h), Nat.cast_inj]
generalize_proofs h1
exact Nat.find_spec h1 | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | exists_coeff_ne_zero_and_weightedOrder | If the order of a formal power series `f` is finite,
then some coefficient of weight equal to the order of `f` is nonzero. |
weightedOrder_le {d : σ →₀ ℕ} (h : coeff d f ≠ 0) :
f.weightedOrder w ≤ weight w d := by
rw [weightedOrder, dif_neg]
· simp only [ne_eq, Nat.cast_le, Nat.find_le_iff]
exact ⟨weight w d, le_rfl, d, h, rfl⟩
· exact (f.ne_zero_iff_exists_coeff_ne_zero_and_weight w).mpr ⟨weight w d, d, h, rfl⟩ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_le | If the `d`th coefficient of a formal power series is nonzero,
then the weighted order of the power series is less than or equal to `weight d w`. |
coeff_eq_zero_of_lt_weightedOrder {d : σ →₀ ℕ} (h : (weight w d) < f.weightedOrder w) :
coeff d f = 0 := by
contrapose! h; exact weightedOrder_le w h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_eq_zero_of_lt_weightedOrder | The `n`th coefficient of a formal power series is `0` if `n` is strictly
smaller than the order of the power series. |
nat_le_weightedOrder {n : ℕ} (h : ∀ d, weight w d < n → coeff d f = 0) :
n ≤ f.weightedOrder w := by
by_contra! H
have : (f.weightedOrder w).toNat = f.weightedOrder w := by
rw [coe_toNat_eq_self]; exact ne_top_of_lt H
obtain ⟨d, hfd, hd⟩ := exists_coeff_ne_zero_and_weightedOrder w this
rw [← hd, Nat.cast_lt] at H
exact hfd (h d H) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | nat_le_weightedOrder | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `weight w d < n`. |
le_weightedOrder {n : ℕ∞} (h : ∀ d : σ →₀ ℕ, weight w d < n → coeff d f = 0) :
n ≤ f.weightedOrder w := by
cases n
· rw [top_le_iff, weightedOrder_eq_top_iff]
ext d; exact h d (ENat.coe_lt_top _)
· apply nat_le_weightedOrder;
simpa only [ENat.some_eq_coe, Nat.cast_lt] using h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | le_weightedOrder | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `weight w d < n`. |
weightedOrder_eq_nat {n : ℕ} :
f.weightedOrder w = n ↔
(∃ d, coeff d f ≠ 0 ∧ weight w d = n) ∧ ∀ d, weight w d < n → coeff d f = 0 := by
constructor
· intro h
obtain ⟨d, hd⟩ := f.exists_coeff_ne_zero_and_weightedOrder w (by simp only [h, toNat_coe])
exact ⟨⟨d, by simpa [h, Nat.cast_inj, ne_eq] using hd⟩,
fun e he ↦ f.coeff_eq_zero_of_lt_weightedOrder w (by simp only [h, Nat.cast_lt, he])⟩
· rintro ⟨⟨d, hd', hd⟩, h⟩
exact le_antisymm (hd.symm ▸ f.weightedOrder_le w hd') (nat_le_weightedOrder w h) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_eq_nat | The order of a formal power series is exactly `n` if and only if some coefficient of weight `n`
is nonzero, and the `d`th coefficient is `0` for all `d` such that `weight w d < n`. |
weightedOrder_monomial {d : σ →₀ ℕ} {a : R} [Decidable (a = 0)] :
weightedOrder w (monomial d a) = if a = 0 then (⊤ : ℕ∞) else weight w d := by
classical
split_ifs with h
· rw [h, weightedOrder_eq_top_iff, LinearMap.map_zero]
· rw [weightedOrder_eq_nat]
constructor
· use d
simp only [coeff_monomial_same, ne_eq, h, not_false_eq_true, and_self]
· intro b hb
rw [coeff_monomial, if_neg]
rintro rfl
exact hb.false | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_monomial | The weighted_order of the monomial `a*X^d` is infinite if `a = 0` and `weight w d` otherwise. |
weightedOrder_monomial_of_ne_zero {d : σ →₀ ℕ} {a : R} (h : a ≠ 0) :
weightedOrder w (monomial d a) = weight w d := by
classical
rw [weightedOrder_monomial, if_neg h]
@[simp] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_monomial_of_ne_zero | The order of the monomial `a*X^n` is `n` if `a ≠ 0`. |
weightedOrder_one [Nontrivial R] : (1 : MvPowerSeries σ R).weightedOrder w = 0 :=
weightedOrder_monomial_of_ne_zero w one_ne_zero | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_one | null |
min_weightedOrder_le_add :
min (f.weightedOrder w) (g.weightedOrder w) ≤ (f + g).weightedOrder w := by
apply le_weightedOrder w
simp +contextual only
[coeff_eq_zero_of_lt_weightedOrder w, lt_min_iff, map_add, add_zero,
imp_true_iff] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | min_weightedOrder_le_add | The order of the sum of two formal power series is at least the minimum of their orders. |
private weightedOrder_add_of_weightedOrder_lt.aux
(H : f.weightedOrder w < g.weightedOrder w) :
(f + g).weightedOrder w = f.weightedOrder w := by
obtain ⟨n, hn : (n : ℕ∞) = _⟩ := ENat.ne_top_iff_exists.mp (ne_top_of_lt H)
rw [← hn, weightedOrder_eq_nat]
obtain ⟨d, hd', hd⟩ := ((weightedOrder_eq_nat w).mp hn.symm).1
constructor
· refine ⟨d, ?_, hd⟩
rw [← hn, ← hd] at H
rw [(coeff _).map_add, coeff_eq_zero_of_lt_weightedOrder w H, add_zero]
exact hd'
· intro b hb
suffices weight w b < weightedOrder w f by
rw [(coeff _).map_add, coeff_eq_zero_of_lt_weightedOrder w this,
coeff_eq_zero_of_lt_weightedOrder w (lt_trans this H), add_zero]
rw [← hn, Nat.cast_lt]
exact hb | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_add_of_weightedOrder_lt.aux | null |
weightedOrder_add_of_weightedOrder_ne (h : f.weightedOrder w ≠ g.weightedOrder w) :
weightedOrder w (f + g) = weightedOrder w f ⊓ weightedOrder w g := by
refine le_antisymm ?_ (min_weightedOrder_le_add w)
wlog H₁ : f.weightedOrder w < g.weightedOrder w
· rw [add_comm f g, inf_comm]
exact this _ h.symm ((le_of_not_gt H₁).lt_of_ne' h)
simp only [le_inf_iff, weightedOrder_add_of_weightedOrder_lt.aux w H₁]
exact ⟨le_rfl, le_of_lt H₁⟩ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_add_of_weightedOrder_ne | The weighted_order of the sum of two formal power series
is the minimum of their orders if their orders differ. |
le_weightedOrder_mul :
f.weightedOrder w + g.weightedOrder w ≤ weightedOrder w (f * g) := by
classical
apply le_weightedOrder
intro d hd
rw [coeff_mul, Finset.sum_eq_zero]
rintro ⟨i, j⟩ hij
by_cases hi : weight w i < f.weightedOrder w
· rw [coeff_eq_zero_of_lt_weightedOrder w hi, zero_mul]
· by_cases hj : weight w j < g.weightedOrder w
· rw [coeff_eq_zero_of_lt_weightedOrder w hj, mul_zero]
· rw [not_lt] at hi hj
simp only [Finset.mem_antidiagonal] at hij
exfalso
apply ne_of_lt (lt_of_lt_of_le hd <| add_le_add hi hj)
rw [← hij, map_add, Nat.cast_add] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | le_weightedOrder_mul | The weighted_order of the product of two formal power series
is at least the sum of their orders. |
le_weightedOrder_prod {R : Type*} [CommSemiring R] {ι : Type*} (w : σ → ℕ)
(f : ι → MvPowerSeries σ R) (s : Finset ι) :
∑ i ∈ s, (f i).weightedOrder w ≤ (∏ i ∈ s, f i).weightedOrder w := 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_weightedOrder_mul _)
alias weightedOrder_mul_ge := le_weightedOrder_mul | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | le_weightedOrder_prod | null |
coeff_mul_left_one_sub_of_lt_weightedOrder
{d : σ →₀ ℕ} (h : (weight w d) < g.weightedOrder w) :
coeff d (f * (1 - g)) = coeff d f := by
simp only [mul_sub, mul_one, map_sub, sub_eq_self]
apply coeff_eq_zero_of_lt_weightedOrder w
exact lt_of_lt_of_le (lt_of_lt_of_le h le_add_self) (le_weightedOrder_mul w) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_left_one_sub_of_lt_weightedOrder | null |
coeff_mul_right_one_sub_of_lt_weightedOrder
{d : σ →₀ ℕ} (h : (weight w d) < g.weightedOrder w) :
coeff d ((1 - g) * f) = coeff d f := by
simp only [sub_mul, one_mul, map_sub, sub_eq_self]
apply coeff_eq_zero_of_lt_weightedOrder w
apply lt_of_lt_of_le (lt_of_lt_of_le h le_self_add) (le_weightedOrder_mul w) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_right_one_sub_of_lt_weightedOrder | null |
coeff_mul_prod_one_sub_of_lt_weightedOrder {R ι : Type*} [CommRing R] (d : σ →₀ ℕ)
(s : Finset ι) (f : MvPowerSeries σ R) (g : ι → MvPowerSeries σ R)
(h : ∀ i ∈ s, (weight w d) < weightedOrder w (g i)) :
coeff d (f * ∏ i ∈ s, (1 - g i)) = coeff d f := by
classical
induction s using Finset.induction_on with
| empty => simp only [Finset.prod_empty, mul_one]
| insert a s ha ih =>
simp only [Finset.mem_insert, forall_eq_or_imp] at h
rw [Finset.prod_insert ha, ← mul_assoc, mul_right_comm,
coeff_mul_left_one_sub_of_lt_weightedOrder w h.1, ih h.2]
@[simp] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_prod_one_sub_of_lt_weightedOrder | null |
weightedOrder_neg (f : MvPowerSeries σ R) : (-f).weightedOrder w = f.weightedOrder w := by
by_contra! h
have : f = 0 := by simpa using (weightedOrder_add_of_weightedOrder_ne w h).symm
simp [this] at h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedOrder_neg | null |
eq_zero_iff_forall_coeff_eq_zero_and :
f = 0 ↔ (∀ d : σ →₀ ℕ, coeff d f = 0) :=
MvPowerSeries.ext_iff | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | eq_zero_iff_forall_coeff_eq_zero_and | null |
ne_zero_iff_exists_coeff_ne_zero_and_degree :
f ≠ 0 ↔ (∃ n : ℕ, ∃ d : σ →₀ ℕ, coeff d f ≠ 0 ∧ degree d = n) := by
simp_rw [degree_eq_weight_one]
exact ne_zero_iff_exists_coeff_ne_zero_and_weight (fun _ => 1) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | ne_zero_iff_exists_coeff_ne_zero_and_degree | null |
order (f : MvPowerSeries σ R) : ℕ∞ := weightedOrder (fun _ => 1) f
@[simp] | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order | The order of a mv_power_series |
order_zero : (0 : MvPowerSeries σ R).order = ⊤ :=
weightedOrder_zero _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_zero | null |
ne_zero_iff_order_finite : f ≠ 0 ↔ f.order.toNat = f.order :=
ne_zero_iff_weightedOrder_finite 1 | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | ne_zero_iff_order_finite | null |
@[simp] order_eq_top_iff : f.order = ⊤ ↔ f = 0 :=
weightedOrder_eq_top_iff _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_eq_top_iff | The `0` power series is the unique power series with infinite order. |
exists_coeff_ne_zero_and_order (h : f.order.toNat = f.order) :
∃ d : σ →₀ ℕ, coeff d f ≠ 0 ∧ degree d = f.order := by
simp_rw [degree_eq_weight_one]
exact exists_coeff_ne_zero_and_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | exists_coeff_ne_zero_and_order | If the order of a formal power series `f` is finite,
then some coefficient of degree the order of `f` is nonzero. |
order_le {d : σ →₀ ℕ} (h : coeff d f ≠ 0) : f.order ≤ degree d := by
rw [degree_eq_weight_one]
exact weightedOrder_le _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_le | If the `d`th coefficient of a formal power series is nonzero,
then the order of the power series is less than or equal to `degree d`. |
coeff_of_lt_order {d : σ →₀ ℕ} (h : degree d < f.order) :
coeff d f = 0 := by
rw [degree_eq_weight_one] at h
exact coeff_eq_zero_of_lt_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_of_lt_order | The `n`th coefficient of a formal power series is `0` if `n` is strictly
smaller than the order of the power series. |
nat_le_order {n : ℕ} (h : ∀ d, degree d < n → coeff d f = 0) :
n ≤ f.order := by
simp_rw [degree_eq_weight_one] at h
exact nat_le_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | nat_le_order | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `degree d < n`. |
le_order {n : ℕ∞} (h : ∀ d : σ →₀ ℕ, degree d < n → coeff d f = 0) :
n ≤ f.order := by
simp_rw [degree_eq_weight_one] at h
exact le_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | le_order | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `degree d < n`. |
order_eq_nat {n : ℕ} :
f.order = n ↔
(∃ d, coeff d f ≠ 0 ∧ degree d = n) ∧ ∀ d, degree d < n → coeff d f = 0 := by
simp_rw [degree_eq_weight_one]
exact weightedOrder_eq_nat _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_eq_nat | The order of a formal power series is exactly `n` some coefficient
of degree `n` is nonzero,
and the `d`th coefficient is `0` for all `d` such that `degree d < n`. |
order_monomial {d : σ →₀ ℕ} {a : R} [Decidable (a = 0)] :
order (monomial d a) = if a = 0 then (⊤ : ℕ∞) else ↑(degree d) := by
rw [degree_eq_weight_one]
exact weightedOrder_monomial _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_monomial | The order of the monomial `a*X^d` is infinite if `a = 0` and `degree d` otherwise. |
order_monomial_of_ne_zero {d : σ →₀ ℕ} {a : R} (h : a ≠ 0) :
order (monomial d a) = degree d := by
rw [degree_eq_weight_one]
exact weightedOrder_monomial_of_ne_zero _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_monomial_of_ne_zero | The order of the monomial `a*X^n` is `n` if `a ≠ 0`. |
min_order_le_add : min f.order g.order ≤ (f + g).order :=
min_weightedOrder_le_add _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | min_order_le_add | The order of the sum of two formal power series
is at least the minimum of their orders. |
order_add_of_order_ne (h : f.order ≠ g.order) :
order (f + g) = order f ⊓ order g :=
weightedOrder_add_of_weightedOrder_ne _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/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 : f.order + g.order ≤ order (f * g) :=
le_weightedOrder_mul _
alias order_mul_ge := le_order_mul | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/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_prod {R : Type*} [CommSemiring R] {ι : Type*}
(f : ι → MvPowerSeries σ R) (s : Finset ι) : ∑ i ∈ s, (f i).order ≤ (∏ i ∈ s, f i).order :=
le_weightedOrder_prod _ _ _ | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | le_order_prod | null |
coeff_mul_left_one_sub_of_lt_order (d : σ →₀ ℕ) (h : degree d < g.order) :
coeff d (f * (1 - g)) = coeff d f := by
rw [degree_eq_weight_one] at h
exact coeff_mul_left_one_sub_of_lt_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_left_one_sub_of_lt_order | null |
coeff_mul_right_one_sub_of_lt_order (d : σ →₀ ℕ) (h : degree d < g.order) :
coeff d ((1 - g) * f) = coeff d f := by
rw [degree_eq_weight_one] at h
exact coeff_mul_right_one_sub_of_lt_weightedOrder _ h | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_right_one_sub_of_lt_order | null |
coeff_mul_prod_one_sub_of_lt_order {R ι : Type*} [CommRing R] (d : σ →₀ ℕ) (s : Finset ι)
(f : MvPowerSeries σ R) (g : ι → MvPowerSeries σ R) :
(∀ i ∈ s, degree d < order (g i)) → coeff d (f * ∏ i ∈ s, (1 - g i)) = coeff d f := by
rw [degree_eq_weight_one]
exact coeff_mul_prod_one_sub_of_lt_weightedOrder _ d s f g
@[simp] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_mul_prod_one_sub_of_lt_order | null |
order_neg (f : MvPowerSeries σ R) : (-f).order = f.order := weightedOrder_neg _ f | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | order_neg | null |
IsWeightedHomogeneous (f : MvPowerSeries σ R) (p : ℕ) : Prop :=
∀ {d : σ →₀ ℕ}, f.coeff d ≠ 0 → weight w d = p
variable {w} in | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsWeightedHomogeneous | Weighted homogeneous power series |
IsWeightedHomogeneous.coeff_eq_zero {f : MvPowerSeries σ R} {p : ℕ}
(hf : f.IsWeightedHomogeneous w p) {d : σ →₀ ℕ} (hd : weight w d ≠ p) :
f.coeff d = 0 := by
simpa [Classical.not_not] using mt (@hf d) hd
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsWeightedHomogeneous.coeff_eq_zero | null |
protected IsWeightedHomogeneous.add {f g : MvPowerSeries σ R} {p : ℕ}
(hf : f.IsWeightedHomogeneous w p) (hg : g.IsWeightedHomogeneous w p) :
(f + g).IsWeightedHomogeneous w p := fun {d} ↦ by
rw [not_imp_comm]
intro hd
rw [map_add, hf.coeff_eq_zero hd, hg.coeff_eq_zero hd, add_zero]
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsWeightedHomogeneous.add | null |
protected IsWeightedHomogeneous.mul {f g : MvPowerSeries σ R} {p q : ℕ}
(hf : f.IsWeightedHomogeneous w p) (hg : g.IsWeightedHomogeneous w q) :
(f * g).IsWeightedHomogeneous w (p + q) := fun {d} ↦ by
classical
rw [not_imp_comm]
intro hd
rw [coeff_mul]
apply Finset.sum_eq_zero
intro x hx
rw [Finset.mem_antidiagonal] at hx
suffices weight w x.1 ≠ p ∨ weight w x.2 ≠ q by
rcases this with hp | hq
· rw [hf.coeff_eq_zero hp, zero_mul]
· rw [hg.coeff_eq_zero hq, mul_zero]
rw [← not_and_or]
rintro ⟨hp, hq⟩
apply hd
rw [← hx, map_add, hp, hq] | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsWeightedHomogeneous.mul | null |
weightedHomogeneousComponent (p : ℕ) : MvPowerSeries σ R →ₗ[R] MvPowerSeries σ R where
toFun f d := if weight w d = p then coeff d f else 0
map_add' f g := by
ext d
simp only [map_add, coeff_apply]
split_ifs with h
· rfl
· rw [add_zero]
map_smul' a f := by
ext d
simp only [map_smul,
smul_eq_mul, RingHom.id_apply, coeff_apply, mul_ite, mul_zero] | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedHomogeneousComponent | The weighted homogeneous components of an `MvPowerSeries f`. |
coeff_weightedHomogeneousComponent (p : ℕ) (d : σ →₀ ℕ) (f : MvPowerSeries σ R) :
coeff d (weightedHomogeneousComponent w p f) =
if weight w d = p then coeff d f else 0 :=
rfl
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_weightedHomogeneousComponent | null |
weightedHomogeneousComponent_of_lt_weightedOrder_eq_zero
{f : MvPowerSeries σ R} {p : ℕ} (hf : p < f.weightedOrder w) :
f.weightedHomogeneousComponent w p = 0 := by
ext d
rw [coeff_weightedHomogeneousComponent]
split_ifs with hd
· rw [coeff_zero]
apply coeff_eq_zero_of_lt_weightedOrder w
rw [hd]
exact hf
· rw [map_zero]
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedHomogeneousComponent_of_lt_weightedOrder_eq_zero | null |
weightedHomogeneousComponent_of_weightedOrder
{f : MvPowerSeries σ R} {p : ℕ} (hf : p = f.weightedOrder w) :
f.weightedHomogeneousComponent w p ≠ 0 := by
intro hf'
obtain ⟨d, hd⟩ := f.exists_coeff_ne_zero_and_weightedOrder w (by rw [← hf, toNat_coe])
simp only [ne_eq, ← hf, Nat.cast_inj] at hd
apply hd.1
rw [MvPowerSeries.ext_iff] at hf'
specialize hf' d
simp only [coeff_weightedHomogeneousComponent, coeff_zero, ite_eq_right_iff] at hf'
exact hf' hd.2 | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedHomogeneousComponent_of_weightedOrder | null |
isWeightedHomogeneous_weightedHomogeneousComponent (f : MvPowerSeries σ R) (p : ℕ) :
IsWeightedHomogeneous w (f.weightedHomogeneousComponent w p) p := fun {d} ↦ by
rw [not_imp_comm]
intro hd
rw [coeff_weightedHomogeneousComponent, if_neg hd]
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | isWeightedHomogeneous_weightedHomogeneousComponent | null |
isWeightedHomogeneous_iff_eq_weightedHomogeneousComponent
{f : MvPowerSeries σ R} {p : ℕ} :
IsWeightedHomogeneous w f p ↔ f = f.weightedHomogeneousComponent w p := by
constructor
· intro hf
ext d
rw [coeff_weightedHomogeneousComponent]
split_ifs with hd
· rfl
· exact hf.coeff_eq_zero hd
· intro hf
rw [hf]
exact isWeightedHomogeneous_weightedHomogeneousComponent w f p
variable {w} in | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | isWeightedHomogeneous_iff_eq_weightedHomogeneousComponent | null |
weightedHomogeneousComponent_mul_of_le_weightedOrder {f g : MvPowerSeries σ R} {p q : ℕ}
(hf : p ≤ f.weightedOrder w) (hg : q ≤ g.weightedOrder w) :
weightedHomogeneousComponent w (p + q) (f * g) =
weightedHomogeneousComponent w p f * weightedHomogeneousComponent w q g := by
classical
ext d
rw [coeff_weightedHomogeneousComponent]
split_ifs with hd
· apply Finset.sum_congr rfl
intro x hx
rw [Finset.mem_antidiagonal] at hx
rw [← hx, map_add] at hd
simp only [coeff_weightedHomogeneousComponent]
rcases trichotomy_of_add_eq_add hd with h | h | h
· rw [if_pos h.1, if_pos h.2]
· rw [if_neg (ne_of_lt h), zero_mul]
rw [← ENat.coe_lt_coe] at h
rw [coeff_eq_zero_of_lt_weightedOrder w (lt_of_lt_of_le h hf), zero_mul]
· rw [if_neg (ne_of_lt h), mul_zero]
rw [← ENat.coe_lt_coe] at h
rw [coeff_eq_zero_of_lt_weightedOrder w (lt_of_lt_of_le h hg), mul_zero]
· symm
apply IsWeightedHomogeneous.coeff_eq_zero _ hd
exact IsWeightedHomogeneous.mul
(isWeightedHomogeneous_weightedHomogeneousComponent w f p)
(isWeightedHomogeneous_weightedHomogeneousComponent w g q) | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | weightedHomogeneousComponent_mul_of_le_weightedOrder | null |
IsHomogeneous (f : MvPowerSeries σ R) (p : ℕ) : Prop :=
IsWeightedHomogeneous 1 f p | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsHomogeneous | Homogeneous power series |
IsHomogeneous.coeff_eq_zero {f : MvPowerSeries σ R} {p : ℕ}
(hf : f.IsHomogeneous p) {d : σ →₀ ℕ} (hd : degree d ≠ p) :
f.coeff d = 0 := by
apply IsWeightedHomogeneous.coeff_eq_zero hf
rwa [degree_eq_weight_one] at hd | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsHomogeneous.coeff_eq_zero | null |
protected IsHomogeneous.add {f g : MvPowerSeries σ R} {p : ℕ}
(hf : f.IsHomogeneous p) (hg : g.IsHomogeneous p) :
(f + g).IsHomogeneous p :=
IsWeightedHomogeneous.add hf hg | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsHomogeneous.add | null |
protected IsHomogeneous.mul {f g : MvPowerSeries σ R} {p q : ℕ}
(hf : f.IsHomogeneous p) (hg : g.IsHomogeneous q) :
(f * g).IsHomogeneous (p + q) :=
IsWeightedHomogeneous.mul hf hg | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | IsHomogeneous.mul | null |
homogeneousComponent (p : ℕ) : MvPowerSeries σ R →ₗ[R] MvPowerSeries σ R :=
weightedHomogeneousComponent 1 p | def | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | homogeneousComponent | The homogeneous components of an `MvPowerSeries` |
coeff_homogeneousComponent (p : ℕ) (d : σ →₀ ℕ) (f : MvPowerSeries σ R) :
coeff d (homogeneousComponent p f) =
if degree d = p then coeff d f else 0 := by
rw [degree_eq_weight_one]
exact coeff_weightedHomogeneousComponent 1 p d f | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | coeff_homogeneousComponent | null |
homogeneousComponent_of_lt_order_eq_zero
{f : MvPowerSeries σ R} {p : ℕ} (hf : p < f.order) :
f.homogeneousComponent p = 0 :=
weightedHomogeneousComponent_of_lt_weightedOrder_eq_zero hf | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | homogeneousComponent_of_lt_order_eq_zero | null |
homogeneousComponent_of_order
{f : MvPowerSeries σ R} {p : ℕ} (hf : p = f.order) :
f.homogeneousComponent p ≠ 0 :=
weightedHomogeneousComponent_of_weightedOrder hf | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | homogeneousComponent_of_order | null |
isHomogeneous_homogeneousComponent (f : MvPowerSeries σ R) (p : ℕ) :
IsHomogeneous (f.homogeneousComponent p) p :=
isWeightedHomogeneous_weightedHomogeneousComponent 1 f p | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | isHomogeneous_homogeneousComponent | null |
isHomogeneous_iff_eq_homogeneousComponent
{f : MvPowerSeries σ R} {p : ℕ} :
IsHomogeneous f p ↔ f = f.homogeneousComponent p :=
isWeightedHomogeneous_iff_eq_weightedHomogeneousComponent | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | isHomogeneous_iff_eq_homogeneousComponent | null |
homogeneousComponent_mul_of_le_order {f g : MvPowerSeries σ R} {p q : ℕ}
(hf : p ≤ f.order) (hg : q ≤ g.order) :
homogeneousComponent (p + q) (f * g) =
homogeneousComponent p f * homogeneousComponent q g :=
weightedHomogeneousComponent_mul_of_le_weightedOrder hf hg | theorem | RingTheory | [
"Mathlib.Data.ENat.Basic",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.MvPowerSeries.Basic"
] | Mathlib/RingTheory/MvPowerSeries/Order.lean | homogeneousComponent_mul_of_le_order | null |
@[scoped instance]
instT0Space [T0Space R] : T0Space (MvPowerSeries σ R) := Pi.instT0Space | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instT0Space | The pointwise topology on `MvPowerSeries` -/
scoped instance : TopologicalSpace (MvPowerSeries σ R) :=
Pi.topologicalSpace
theorem instTopologicalSpace_mono (σ : Type*) {R : Type*} {t u : TopologicalSpace R} (htu : t ≤ u) :
@instTopologicalSpace σ R t ≤ @instTopologicalSpace σ R u := by
simp only [instTopologicalSpace, Pi.topologicalSpace, le_iInf_iff]
grw [htu]
exact iInf_le _
/-- `MvPowerSeries` on a `T0Space` form a `T0Space` |
@[scoped instance]
instT2Space [T2Space R] : T2Space (MvPowerSeries σ R) := Pi.t2Space
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instT2Space | `MvPowerSeries` on a `T2Space` form a `T2Space` |
@[fun_prop]
continuous_coeff [Semiring R] (d : σ →₀ ℕ) :
Continuous (MvPowerSeries.coeff (R := R) d) :=
continuous_pi_iff.mp continuous_id d
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | continuous_coeff | `MvPowerSeries.coeff` is continuous. |
continuous_constantCoeff [Semiring R] : Continuous (constantCoeff (σ := σ) (R := R)) :=
continuous_coeff (R := R) 0 | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | continuous_constantCoeff | `MvPowerSeries.constantCoeff` is continuous |
tendsto_iff_coeff_tendsto [Semiring R] {ι : Type*}
(f : ι → MvPowerSeries σ R) (u : Filter ι) (g : MvPowerSeries σ R) :
Tendsto f u (nhds g) ↔
∀ d : σ →₀ ℕ, Tendsto (fun i => coeff d (f i)) u (nhds (coeff d g)) := by
rw [nhds_pi, tendsto_pi]
exact forall_congr' (fun d => Iff.rfl) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | tendsto_iff_coeff_tendsto | A family of power series converges iff it converges coefficientwise |
tendsto_trunc'_atTop [DecidableEq σ] [CommSemiring R] (f : MvPowerSeries σ R) :
Tendsto (fun d ↦ (trunc' R d f : MvPowerSeries σ R)) 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.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | tendsto_trunc'_atTop | null |
tendsto_trunc_atTop [DecidableEq σ] [CommSemiring R] [Nonempty σ] (f : MvPowerSeries σ R) :
Tendsto (fun d ↦ (trunc R d f : MvPowerSeries σ R)) atTop (𝓝 f) := by
rw [tendsto_iff_coeff_tendsto]
intro d
obtain ⟨s, _⟩ := (exists_const σ).mpr trivial
apply tendsto_atTop_of_eventually_const (i₀ := d + Finsupp.single s 1)
intro n hn
rw [MvPolynomial.coeff_coe, coeff_trunc, if_pos]
apply lt_of_lt_of_le _ hn
simp only [lt_add_iff_pos_right, Finsupp.lt_def]
refine ⟨zero_le _, ⟨s, by simp⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | tendsto_trunc_atTop | null |
denseRange_toMvPowerSeries [CommSemiring R] :
DenseRange (MvPolynomial.toMvPowerSeries (R := R) (σ := σ)) := fun f ↦ by
classical
exact mem_closure_of_tendsto (tendsto_trunc'_atTop f) <| .of_forall fun _ ↦ Set.mem_range_self _
@[deprecated (since := "2025-05-21")] alias toMvPowerSeries_denseRange := denseRange_toMvPowerSeries
variable (σ R) | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | denseRange_toMvPowerSeries | The inclusion of polynomials into power series has dense image |
@[scoped instance]
instIsTopologicalSemiring [Semiring R] [IsTopologicalSemiring R] :
IsTopologicalSemiring (MvPowerSeries σ R) where
continuous_add := continuous_pi fun d => continuous_add.comp
(((continuous_coeff R d).fst').prodMk (continuous_coeff R d).snd')
continuous_mul := continuous_pi fun _ =>
continuous_finset_sum _ fun i _ => continuous_mul.comp
((continuous_coeff R i.fst).fst'.prodMk (continuous_coeff R i.snd).snd') | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instIsTopologicalSemiring | The semiring topology on `MvPowerSeries` of a topological semiring |
@[scoped instance]
instIsTopologicalRing [Ring R] [IsTopologicalRing R] :
IsTopologicalRing (MvPowerSeries σ R) :=
{ instIsTopologicalSemiring σ R with
continuous_neg := continuous_pi fun d ↦ Continuous.comp continuous_neg
(continuous_coeff R d) }
variable {σ R}
@[fun_prop] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instIsTopologicalRing | The ring topology on `MvPowerSeries` of a topological ring |
continuous_C [Semiring R] :
Continuous (C (σ := σ) (R := R)) := by
classical
simp only [continuous_iff_continuousAt]
refine fun r ↦ (tendsto_iff_coeff_tendsto _ _ _).mpr fun d ↦ ?_
simp only [coeff_C]
split_ifs
· exact tendsto_id
· exact tendsto_const_nhds | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | continuous_C | null |
isTopologicallyNilpotent_iff_constantCoeff_isNilpotent
[CommRing R] [DiscreteTopology R] (f : MvPowerSeries σ R) :
IsTopologicallyNilpotent f ↔ IsNilpotent (constantCoeff f) := by
refine ⟨fun H ↦ ?_, isTopologicallyNilpotent_of_constantCoeff_isNilpotent⟩
replace H := H.map (continuous_constantCoeff R)
simp_rw [IsTopologicallyNilpotent, nhds_discrete, tendsto_pure] at H
exact H.exists
variable [Semiring R] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | isTopologicallyNilpotent_iff_constantCoeff_isNilpotent | Scalar multiplication on `MvPowerSeries` is continuous. -/
instance {S : Type*} [Semiring S] [TopologicalSpace S]
[CommSemiring R] [Algebra R S] [ContinuousSMul R S] :
ContinuousSMul R (MvPowerSeries σ S) :=
instContinuousSMulForall
theorem variables_tendsto_zero [Semiring R] :
Tendsto (X · : σ → MvPowerSeries σ R) cofinite (nhds 0) := by
classical
simp only [tendsto_iff_coeff_tendsto, ← coeff_apply, coeff_X, coeff_zero]
refine fun d ↦ tendsto_nhds_of_eventually_eq ?_
by_cases h : ∃ i, d = Finsupp.single i 1
· obtain ⟨i, hi⟩ := h
filter_upwards [eventually_cofinite_ne i] with j hj
simp [hi, Finsupp.single_eq_single_iff, hj.symm]
· simpa only [ite_eq_right_iff] using
Eventually.of_forall fun x h' ↦ (not_exists.mp h x h').elim
theorem isTopologicallyNilpotent_of_constantCoeff_isNilpotent [CommSemiring R]
{f : MvPowerSeries σ R} (hf : IsNilpotent (constantCoeff f)) :
IsTopologicallyNilpotent f := by
classical
obtain ⟨m, hm⟩ := hf
simp_rw [IsTopologicallyNilpotent, tendsto_iff_coeff_tendsto, coeff_zero]
exact fun d ↦ tendsto_atTop_of_eventually_const fun n hn ↦
coeff_eq_zero_of_constantCoeff_nilpotent hm hn
theorem isTopologicallyNilpotent_of_constantCoeff_zero [CommSemiring R]
{f : MvPowerSeries σ R} (hf : constantCoeff f = 0) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) := by
apply isTopologicallyNilpotent_of_constantCoeff_isNilpotent
rw [hf]
exact IsNilpotent.zero
/-- Assuming the base ring has a discrete topology, the powers of a `MvPowerSeries` converge to 0
iff its constant coefficient is nilpotent.
[N. Bourbaki, *Algebra {II}*, Chapter 4, §4, n°2, corollary of prop. 3][bourbaki1981]
See also `MvPowerSeries.LinearTopology.isTopologicallyNilpotent_iff_constantCoeff`. |
hasSum_of_monomials_self (f : MvPowerSeries σ R) :
HasSum (fun d : σ →₀ ℕ => monomial d (coeff d f)) f := by
rw [Pi.hasSum]
intro d
convert hasSum_single d ?_ using 1
· exact (coeff_monomial_same d _).symm
· exact fun d' h ↦ coeff_monomial_ne (Ne.symm h) _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | hasSum_of_monomials_self | A multivariate power series is the sum (in the sense of summable families) of its monomials |
as_tsum [T2Space R] (f : MvPowerSeries σ R) :
f = tsum fun d : σ →₀ ℕ => monomial d (coeff d f) :=
(HasSum.tsum_eq (hasSum_of_monomials_self _)).symm | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | as_tsum | If the coefficient space is T2, then the multivariate power series is `tsum` of its monomials |
hasSum_iff_hasSum_coeff {g : MvPowerSeries σ R} :
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.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/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 ⟨a, by simpa using h⟩
variable [LinearOrder ι] [LocallyFiniteOrderBot ι] | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | summable_iff_summable_coeff | null |
summable_of_tendsto_weightedOrder_atTop_nhds_top {w : σ → ℕ}
(h : Tendsto (fun i ↦ weightedOrder w (f i)) atTop (𝓝 ⊤)) : Summable f := by
rcases isEmpty_or_nonempty ι with hempty | hempty
· apply summable_empty
rw [summable_iff_summable_coeff]
simp_rw [ENat.tendsto_nhds_top_iff_natCast_lt, Filter.eventually_atTop] at h
intro d
obtain ⟨i, hi⟩ := h (Finsupp.weight w d)
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_eq_zero_of_lt_weightedOrder w <| hi k hk.le | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | summable_of_tendsto_weightedOrder_atTop_nhds_top | A family of `MvPowerSeries` is summable if their weighted order tends to infinity. |
summable_of_tendsto_order_atTop_nhds_top
(h : Tendsto (fun i ↦ (f i).order) atTop (𝓝 ⊤)) : Summable f :=
summable_of_tendsto_weightedOrder_atTop_nhds_top h | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | summable_of_tendsto_order_atTop_nhds_top | A family of `MvPowerSeries` is summable if their order tends to infinity. |
uniformContinuous_coeff [Semiring R] (d : σ →₀ ℕ) :
UniformContinuous fun f : MvPowerSeries σ R => coeff d f :=
uniformContinuous_pi.mp uniformContinuous_id d | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | uniformContinuous_coeff | The componentwise uniformity on `MvPowerSeries` -/
scoped instance : UniformSpace (MvPowerSeries σ R) :=
Pi.uniformSpace fun _ : σ →₀ ℕ => R
variable (R) in
/-- Coefficients of a multivariate power series are uniformly continuous |
@[scoped instance]
instCompleteSpace [CompleteSpace R] :
CompleteSpace (MvPowerSeries σ R) := Pi.complete _ | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instCompleteSpace | Completeness of the uniform structure on `MvPowerSeries` |
@[scoped instance]
instIsUniformAddGroup [AddGroup R] [IsUniformAddGroup R] :
IsUniformAddGroup (MvPowerSeries σ R) := Pi.instIsUniformAddGroup
@[deprecated (since := "2025-03-27")] alias instUniformAddGroup := instIsUniformAddGroup | theorem | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.Order",
"Mathlib.RingTheory.MvPowerSeries.Trunc",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.Topology.Algebra.InfiniteSum.Constructions",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",... | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | instIsUniformAddGroup | The `IsUniformAddGroup` structure on `MvPowerSeries` of a `IsUniformAddGroup` |
@[mk_iff hasSubst_def]
HasSubst (a : σ → MvPowerSeries τ S) : Prop where
const_coeff s : IsNilpotent (constantCoeff (a s))
coeff_zero d : {s | (a s).coeff d ≠ 0}.Finite
variable {a : σ → MvPowerSeries τ S} | structure | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | HasSubst | Families of power series which can be substituted |
coeff_zero_iff [TopologicalSpace S] [DiscreteTopology S] :
Filter.Tendsto a Filter.cofinite (nhds 0) ↔
∀ d : τ →₀ ℕ, {s | (a s).coeff d ≠ 0}.Finite := by
simp [tendsto_iff_coeff_tendsto, coeff_zero, nhds_discrete] | lemma | RingTheory | [
"Mathlib.RingTheory.MvPowerSeries.Evaluation",
"Mathlib.RingTheory.MvPowerSeries.LinearTopology",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.Topology.UniformSpace.DiscreteUniformity"
] | Mathlib/RingTheory/MvPowerSeries/Substitution.lean | coeff_zero_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.