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 ⌀ |
|---|---|---|---|---|---|---|
mul_X_pow_cancel {k : ℕ} {φ ψ : R⟦X⟧} (h : φ * X ^ k = ψ * X ^ k) :
φ = ψ := by
rw [PowerSeries.ext_iff] at h ⊢
intro n
simpa using h (n + k) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | mul_X_pow_cancel | null |
mul_X_pow_injective {k : ℕ} : Function.Injective (· * X ^ k : R⟦X⟧ → R⟦X⟧) :=
fun _ _ ↦ mul_X_pow_cancel | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | mul_X_pow_injective | null |
mul_X_pow_inj {k : ℕ} {φ ψ : R⟦X⟧} :
φ * X ^ k = ψ * X ^ k ↔ φ = ψ :=
mul_X_pow_injective.eq_iff | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | mul_X_pow_inj | null |
X_pow_mul_cancel {k : ℕ} {φ ψ : R⟦X⟧} (h : X ^ k * φ = X ^ k * ψ) :
φ = ψ := by
rw [PowerSeries.ext_iff] at h ⊢
intro n
simpa using h (n + k) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | X_pow_mul_cancel | null |
X_pow_mul_injective {k : ℕ} : Function.Injective (X ^ k * · : R⟦X⟧ → R⟦X⟧) :=
fun _ _ ↦ X_pow_mul_cancel | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | X_pow_mul_injective | null |
X_pow_mul_inj {k : ℕ} {φ ψ : R⟦X⟧} :
X ^ k * φ = X ^ k * ψ ↔ φ = ψ :=
X_pow_mul_injective.eq_iff | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | X_pow_mul_inj | null |
coeff_mul_X_pow' (p : R⟦X⟧) (n d : ℕ) :
coeff d (p * X ^ n) = ite (n ≤ d) (coeff (d - n) p) 0 := by
split_ifs with h
· rw [← tsub_add_cancel_of_le h, coeff_mul_X_pow, add_tsub_cancel_right]
· refine (coeff_mul _ _ _).trans (Finset.sum_eq_zero fun x hx => ?_)
rw [coeff_X_pow, if_neg, mul_zero]
exact ((le_of_add_le_right (mem_antidiagonal.mp hx).le).trans_lt <| not_le.mp h).ne | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_mul_X_pow' | null |
coeff_X_pow_mul' (p : R⟦X⟧) (n d : ℕ) :
coeff d (X ^ n * p) = ite (n ≤ d) (coeff (d - n) p) 0 := by
split_ifs with h
· rw [← tsub_add_cancel_of_le h, coeff_X_pow_mul]
simp
· refine (coeff_mul _ _ _).trans (Finset.sum_eq_zero fun x hx => ?_)
rw [coeff_X_pow, if_neg, zero_mul]
have := mem_antidiagonal.mp hx
rw [add_comm] at this
exact ((le_of_add_le_right this.le).trans_lt <| not_le.mp h).ne | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_X_pow_mul' | null |
isUnit_constantCoeff (φ : R⟦X⟧) (h : IsUnit φ) : IsUnit (constantCoeff φ) :=
MvPowerSeries.isUnit_constantCoeff φ h | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | isUnit_constantCoeff | If a formal power series is invertible, then so is its constant coefficient. |
eq_shift_mul_X_add_const (φ : R⟦X⟧) :
φ = (mk fun p => coeff (p + 1) φ) * X + C (constantCoeff φ) := by
ext (_ | n)
· simp only [coeff_zero_eq_constantCoeff, map_add, map_mul, constantCoeff_X,
mul_zero, coeff_zero_C, zero_add]
· simp only [coeff_succ_mul_X, coeff_mk, LinearMap.map_add, coeff_C, n.succ_ne_zero,
if_false, add_zero] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | eq_shift_mul_X_add_const | Split off the constant coefficient. |
eq_X_mul_shift_add_const (φ : R⟦X⟧) :
φ = (X * mk fun p => coeff (p + 1) φ) + C (constantCoeff φ) := by
ext (_ | n)
· simp only [coeff_zero_eq_constantCoeff, map_add, map_mul, constantCoeff_X,
zero_mul, coeff_zero_C, zero_add]
· simp only [coeff_succ_X_mul, coeff_mk, LinearMap.map_add, coeff_C, n.succ_ne_zero,
if_false, add_zero] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | eq_X_mul_shift_add_const | Split off the constant coefficient. |
map : R⟦X⟧ →+* S⟦X⟧ :=
MvPowerSeries.map f
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map | The map between formal power series induced by a map on the coefficients. |
map_id : (map (RingHom.id R) : R⟦X⟧ → R⟦X⟧) = id :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_id | null |
map_comp : map (g.comp f) = (map g).comp (map f) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_comp | null |
coeff_map (n : ℕ) (φ : R⟦X⟧) : coeff n (map f φ) = f (coeff n φ) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_map | null |
map_C (r : R) : map f (C r) = C (f r) := by
ext
simp [coeff_C, apply_ite f]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_C | null |
map_X : map f X = X := by
ext
simp [coeff_X, apply_ite f] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_X | null |
map_surjective (f : S →+* T) (hf : Function.Surjective f) :
Function.Surjective (PowerSeries.map f) := by
intro g
use PowerSeries.mk fun k ↦ Function.surjInv hf (PowerSeries.coeff k g)
ext k
simp only [Function.surjInv, coeff_map, coeff_mk]
exact Classical.choose_spec (hf (coeff k g)) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_surjective | null |
map_injective (f : S →+* T) (hf : Function.Injective ⇑f) :
Function.Injective (PowerSeries.map f) := by
intro u v huv
ext k
apply hf
rw [← PowerSeries.coeff_map, ← PowerSeries.coeff_map, huv] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_injective | null |
@[simp]
map_eq_zero {R S : Type*} [DivisionSemiring R] [Semiring S] [Nontrivial S] (φ : R⟦X⟧)
(f : R →+* S) : φ.map f = 0 ↔ φ = 0 :=
MvPowerSeries.map_eq_zero _ _ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | map_eq_zero | null |
X_pow_dvd_iff {n : ℕ} {φ : R⟦X⟧} :
(X : R⟦X⟧) ^ n ∣ φ ↔ ∀ m, m < n → coeff m φ = 0 := by
convert @MvPowerSeries.X_pow_dvd_iff Unit R _ () n φ
constructor <;> intro h m hm
· rw [Finsupp.unique_single m]
convert h _ hm
· apply h
simpa only [Finsupp.single_eq_same] using hm | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | X_pow_dvd_iff | null |
X_dvd_iff {φ : R⟦X⟧} : (X : R⟦X⟧) ∣ φ ↔ constantCoeff φ = 0 := by
rw [← pow_one (X : R⟦X⟧), X_pow_dvd_iff, ← coeff_zero_eq_constantCoeff_apply]
constructor <;> intro h
· exact h 0 zero_lt_one
· intro m hm
rwa [Nat.eq_zero_of_le_zero (Nat.le_of_succ_le_succ hm)] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | X_dvd_iff | null |
noncomputable rescale (a : R) : R⟦X⟧ →+* R⟦X⟧ where
toFun f := PowerSeries.mk fun n => a ^ n * PowerSeries.coeff n f
map_zero' := by
ext
simp only [LinearMap.map_zero, PowerSeries.coeff_mk, mul_zero]
map_one' := by
ext1
simp only [mul_boole, PowerSeries.coeff_mk, PowerSeries.coeff_one]
split_ifs with h
· rw [h, pow_zero a]
rfl
map_add' := by
intros
ext
dsimp only
exact mul_add _ _ _
map_mul' f g := by
ext
rw [PowerSeries.coeff_mul, PowerSeries.coeff_mk, PowerSeries.coeff_mul, Finset.mul_sum]
apply sum_congr rfl
simp only [coeff_mk, Prod.forall, mem_antidiagonal]
intro b c H
rw [← H, pow_add, mul_mul_mul_comm]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale | The ring homomorphism taking a power series `f(X)` to `f(aX)`. |
coeff_rescale (f : R⟦X⟧) (a : R) (n : ℕ) :
coeff n (rescale a f) = a ^ n * coeff n f :=
coeff_mk n (fun n ↦ a ^ n * coeff n f)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_rescale | null |
rescale_zero : rescale 0 = (C (R := R)).comp constantCoeff := by
ext x n
simp only [Function.comp_apply, RingHom.coe_comp, rescale, RingHom.coe_mk,
coeff_C]
split_ifs with h <;> simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_zero | null |
rescale_zero_apply (f : R⟦X⟧) : rescale 0 f = C (constantCoeff f) := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_zero_apply | null |
rescale_one : rescale 1 = RingHom.id R⟦X⟧ := by
ext
simp [coeff_rescale] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_one | null |
rescale_mk (f : ℕ → R) (a : R) : rescale a (mk f) = mk fun n : ℕ => a ^ n * f n := by
ext
rw [coeff_rescale, coeff_mk, coeff_mk] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_mk | null |
rescale_rescale (f : R⟦X⟧) (a b : R) :
rescale b (rescale a f) = rescale (a * b) f := by
ext n
simp_rw [coeff_rescale]
rw [mul_pow, mul_comm _ (b ^ n), mul_assoc] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_rescale | null |
rescale_mul (a b : R) : rescale (a * b) = (rescale b).comp (rescale a) := by
ext
simp [← rescale_rescale] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_mul | null |
coeff_prod [DecidableEq ι] (f : ι → PowerSeries R) (d : ℕ) (s : Finset ι) :
coeff d (∏ j ∈ s, f j) = ∑ l ∈ finsuppAntidiag s d, ∏ i ∈ s, coeff (l i) (f i) := by
simp only [coeff]
rw [MvPowerSeries.coeff_prod, ← AddEquiv.finsuppUnique_symm d, ← mapRange_finsuppAntidiag_eq,
sum_map, sum_congr rfl]
intro x _
apply prod_congr rfl
intro i _
congr 2
simp only [AddEquiv.toEquiv_eq_coe, Finsupp.mapRange.addEquiv_toEquiv, AddEquiv.toEquiv_symm,
Equiv.coe_toEmbedding, Finsupp.mapRange.equiv_apply, AddEquiv.coe_toEquiv_symm,
Finsupp.mapRange_apply, AddEquiv.finsuppUnique_symm] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_prod | Coefficients of a product of power series |
prod_monomial (f : ι → ℕ) (g : ι → R) (s : Finset ι) :
∏ i ∈ s, monomial (f i) (g i) = monomial (∑ i ∈ s, f i) (∏ i ∈ s, g i) := by
simpa [monomial, Finsupp.single_finset_sum] using
MvPowerSeries.prod_monomial (fun i ↦ Finsupp.single () (f i)) g s | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | prod_monomial | null |
monmial_pow (m : ℕ) (a : R) (n : ℕ) : (monomial m a) ^ n = monomial (n * m) (a ^ n) := by
simpa [monomial] using MvPowerSeries.monmial_pow (Finsupp.single () m) a n | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | monmial_pow | null |
coeff_pow (k n : ℕ) (φ : R⟦X⟧) :
coeff n (φ ^ k) = ∑ l ∈ finsuppAntidiag (range k) n, ∏ i ∈ range k, coeff (l i) φ := by
have h₁ (i : ℕ) : Function.const ℕ φ i = φ := rfl
have h₂ (i : ℕ) : ∏ j ∈ range i, Function.const ℕ φ j = φ ^ i := by
apply prod_range_induction (fun _ => φ) (fun i => φ ^ i) rfl i (fun _ => congrFun rfl)
rw [← h₂, ← h₁ k]
apply coeff_prod (f := Function.const ℕ φ) (d := n) (s := range k) | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_pow | The `n`-th coefficient of the `k`-th power of a power series. |
coeff_one_mul (φ ψ : R⟦X⟧) : coeff 1 (φ * ψ) =
coeff 1 φ * constantCoeff ψ + coeff 1 ψ * constantCoeff φ := by
have : Finset.antidiagonal 1 = {(0, 1), (1, 0)} := by exact rfl
rw [coeff_mul, this, Finset.sum_insert, Finset.sum_singleton, coeff_zero_eq_constantCoeff,
mul_comm, add_comm]
simp | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_one_mul | First coefficient of the product of two power series. |
coeff_one_pow (n : ℕ) (φ : R⟦X⟧) :
coeff 1 (φ ^ n) = n * coeff 1 φ * (constantCoeff φ) ^ (n - 1) := by
rcases Nat.eq_zero_or_pos n with (rfl | hn)
· simp
induction n with
| zero => cutsat
| succ n' ih =>
have h₁ (m : ℕ) : φ ^ (m + 1) = φ ^ m * φ := by exact rfl
have h₂ : Finset.antidiagonal 1 = {(0, 1), (1, 0)} := by exact rfl
rw [h₁, coeff_mul, h₂, Finset.sum_insert, Finset.sum_singleton]
· simp only [coeff_zero_eq_constantCoeff, map_pow, Nat.cast_add, Nat.cast_one,
add_tsub_cancel_right]
have h₀ : n' = 0 ∨ 1 ≤ n' := by omega
rcases h₀ with h' | h'
· by_contra h''
rw [h'] at h''
simp only [pow_zero, one_mul, coeff_one, one_ne_zero, ↓reduceIte, zero_mul, add_zero,
mul_one] at h''
norm_num at h''
· rw [ih]
· conv => lhs; arg 2; rw [mul_comm, ← mul_assoc]
move_mul [← constantCoeff φ ^ (n' - 1)]
conv => enter [1, 2, 1, 1, 2]; rw [← pow_one (a := constantCoeff φ)]
rw [← pow_add (a := constantCoeff φ)]
conv => enter [1, 2, 1, 1]; rw [Nat.sub_add_cancel h']
ring
exact h'
· decide | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_one_pow | First coefficient of the `n`-th power of a power series. |
not_isField : ¬IsField A⟦X⟧ := by
by_cases hA : Subsingleton A
· exact not_isField_of_subsingleton _
· nontriviality A
rw [Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top]
use Ideal.span {X}
constructor
· rw [bot_lt_iff_ne_bot, Ne, Ideal.span_singleton_eq_bot]
exact X_ne_zero
· rw [lt_top_iff_ne_top, Ne, Ideal.eq_top_iff_one, Ideal.mem_span_singleton,
X_dvd_iff, constantCoeff_one]
exact one_ne_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | not_isField | null |
rescale_X (a : A) : rescale a X = C a * X := by
ext
simp only [coeff_rescale, coeff_C_mul, coeff_X]
split_ifs with h <;> simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_X | null |
rescale_neg_one_X : rescale (-1 : A) X = -X := by
rw [rescale_X, map_neg, map_one, neg_one_mul] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | rescale_neg_one_X | null |
noncomputable evalNegHom : A⟦X⟧ →+* A⟦X⟧ :=
rescale (-1 : A)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | evalNegHom | The ring homomorphism taking a power series `f(X)` to `f(-X)`. |
evalNegHom_X : evalNegHom (X : A⟦X⟧) = -X :=
rescale_neg_one_X | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | evalNegHom_X | null |
C_eq_algebraMap {r : R} : C r = (algebraMap R R⟦X⟧) r :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | C_eq_algebraMap | null |
algebraMap_apply {r : R} : algebraMap R A⟦X⟧ r = C (algebraMap R A r) :=
MvPowerSeries.algebraMap_apply | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | algebraMap_apply | null |
mapAlgHom (φ : A →ₐ[R] B) :
PowerSeries A →ₐ[R] PowerSeries B :=
MvPowerSeries.mapAlgHom φ | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | mapAlgHom | Change of coefficients in power series, as an `AlgHom` |
mapAlgHom_apply (φ : A →ₐ[R] B) (f : A⟦X⟧) :
mapAlgHom φ f = f.map φ :=
MvPowerSeries.mapAlgHom_apply φ f | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | mapAlgHom_apply | null |
@[coe]
toPowerSeries : R[X] → PowerSeries R := fun φ =>
PowerSeries.mk fun n => coeff φ n | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | toPowerSeries | The natural inclusion from polynomials into formal power series. |
coeToPowerSeries : Coe R[X] (PowerSeries R) :=
⟨toPowerSeries⟩ | instance | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeToPowerSeries | The natural inclusion from polynomials into formal power series. |
coe_def : (φ : PowerSeries R) = PowerSeries.mk (coeff φ) :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_def | null |
coeff_coe (n) : PowerSeries.coeff n φ = coeff φ n :=
congr_arg (coeff φ) Finsupp.single_eq_same
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeff_coe | null |
coe_monomial (n : ℕ) (a : R) :
(monomial n a : PowerSeries R) = PowerSeries.monomial n a := by
ext
simp [coeff_coe, PowerSeries.coeff_monomial, Polynomial.coeff_monomial, eq_comm]
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_monomial | null |
coe_zero : ((0 : R[X]) : PowerSeries R) = 0 :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_zero | null |
coe_one : ((1 : R[X]) : PowerSeries R) = 1 := by
have := coe_monomial 0 (1 : R)
rwa [PowerSeries.monomial_zero_eq_C_apply] at this
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_one | null |
coe_add : ((φ + ψ : R[X]) : PowerSeries R) = φ + ψ := by
ext
simp
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_add | null |
coe_mul : ((φ * ψ : R[X]) : PowerSeries R) = φ * ψ :=
PowerSeries.ext fun n => by simp only [coeff_coe, PowerSeries.coeff_mul, coeff_mul]
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_mul | null |
coe_C (a : R) : ((C a : R[X]) : PowerSeries R) = PowerSeries.C a := by
have := coe_monomial 0 a
rwa [PowerSeries.monomial_zero_eq_C_apply] at this
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_C | null |
coe_X : ((X : R[X]) : PowerSeries R) = PowerSeries.X :=
coe_monomial _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_X | null |
polynomial_map_coe {U V : Type*} [CommSemiring U] [CommSemiring V] {φ : U →+* V}
{f : Polynomial U} : Polynomial.map φ f = PowerSeries.map φ f := by
ext
simp
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | polynomial_map_coe | null |
constantCoeff_coe : PowerSeries.constantCoeff φ = φ.coeff 0 :=
rfl
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | constantCoeff_coe | null |
coe_injective : Function.Injective ((↑) : R[X] → PowerSeries R) := fun x y h => by
ext
simp_rw [← coeff_coe, h]
variable {R φ ψ}
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_injective | null |
coe_inj : (φ : PowerSeries R) = ψ ↔ φ = ψ :=
(coe_injective R).eq_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_inj | null |
coe_eq_zero_iff : (φ : PowerSeries R) = 0 ↔ φ = 0 := by rw [← coe_zero, coe_inj]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_eq_zero_iff | null |
coe_eq_one_iff : (φ : PowerSeries R) = 1 ↔ φ = 1 := by rw [← coe_one, coe_inj] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_eq_one_iff | null |
coeToPowerSeries.ringHom : R[X] →+* PowerSeries R where
toFun := (↑)
map_zero' := coe_zero
map_one' := coe_one
map_add' := coe_add
map_mul' := coe_mul
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeToPowerSeries.ringHom | The coercion from polynomials to power series
as a ring homomorphism. |
coeToPowerSeries.ringHom_apply : coeToPowerSeries.ringHom φ = φ :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeToPowerSeries.ringHom_apply | null |
coe_pow (n : ℕ) : ((φ ^ n : R[X]) : PowerSeries R) = (φ : PowerSeries R) ^ n :=
coeToPowerSeries.ringHom.map_pow _ _ | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_pow | null |
eval₂_C_X_eq_coe : φ.eval₂ PowerSeries.C PowerSeries.X = ↑φ := by
nth_rw 2 [← eval₂_C_X (p := φ)]
rw [← coeToPowerSeries.ringHom_apply, eval₂_eq_sum_range, eval₂_eq_sum_range, map_sum]
apply Finset.sum_congr rfl
intros
rw [map_mul, map_pow, coeToPowerSeries.ringHom_apply,
coeToPowerSeries.ringHom_apply, coe_C, coe_X] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | eval₂_C_X_eq_coe | null |
_root_.MvPolynomial.toMvPowerSeries_pUnitAlgEquiv {f : MvPolynomial PUnit R} :
(f.toMvPowerSeries : PowerSeries R) = (f.pUnitAlgEquiv R).toPowerSeries := by
induction f using MvPolynomial.induction_on' with
| monomial d r =>
have : single () (d ()) = d := by ext; simp
simp only [MvPolynomial.coe_monomial, MvPolynomial.pUnitAlgEquiv_monomial,
Polynomial.coe_monomial, PowerSeries.monomial, this]
| add f g hf hg => simp [hf, hg] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | _root_.MvPolynomial.toMvPowerSeries_pUnitAlgEquiv | null |
pUnitAlgEquiv_symm_toPowerSeries {f : Polynomial R} :
((f.toPowerSeries) : MvPowerSeries PUnit R)
= ((MvPolynomial.pUnitAlgEquiv R).symm f).toMvPowerSeries := by
set g := (MvPolynomial.pUnitAlgEquiv R).symm f
have : f = MvPolynomial.pUnitAlgEquiv R g := by simp only [g, AlgEquiv.apply_symm_apply]
rw [this, MvPolynomial.toMvPowerSeries_pUnitAlgEquiv]
variable (A : Type*) [Semiring A] [Algebra R A] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | pUnitAlgEquiv_symm_toPowerSeries | null |
coeToPowerSeries.algHom : R[X] →ₐ[R] PowerSeries A :=
{ (PowerSeries.map (algebraMap R A)).comp coeToPowerSeries.ringHom with
commutes' := fun r => by simp [PowerSeries.algebraMap_apply] }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeToPowerSeries.algHom | The coercion from polynomials to power series
as an algebra homomorphism. |
coeToPowerSeries.algHom_apply :
coeToPowerSeries.algHom A φ = PowerSeries.map (algebraMap R A) ↑φ :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coeToPowerSeries.algHom_apply | null |
@[simp, norm_cast]
coe_neg (p : R[X]) : ((-p : R[X]) : PowerSeries R) = -p :=
coeToPowerSeries.ringHom.map_neg p
@[simp, norm_cast] | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_neg | null |
coe_sub (p q : R[X]) : ((p - q : R[X]) : PowerSeries R) = p - q :=
coeToPowerSeries.ringHom.map_sub p q | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | coe_sub | null |
algebraPolynomial : Algebra R[X] A⟦X⟧ :=
RingHom.toAlgebra (Polynomial.coeToPowerSeries.algHom A).toRingHom | instance | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | algebraPolynomial | null |
algebraPowerSeries : Algebra R⟦X⟧ A⟦X⟧ :=
(map (algebraMap R A)).toAlgebra | instance | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | algebraPowerSeries | null |
algebraMap_apply' (p : R[X]) : algebraMap R[X] A⟦X⟧ p = map (algebraMap R A) p :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | algebraMap_apply' | null |
algebraMap_apply'' :
algebraMap R⟦X⟧ A⟦X⟧ f = map (algebraMap R A) f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.RingTheory.MvPowerSeries.Basic",
"Mathlib.Tactic.MoveAdd",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.RingTheory.Ideal.Basic"
] | Mathlib/RingTheory/PowerSeries/Basic.lean | algebraMap_apply'' | null |
binomialSeries (A) [One A] [SMul R A] (r : R) : PowerSeries A :=
mk fun n => Ring.choose r n • 1
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries | The power series for `(1 + X) ^ r`. |
binomialSeries_coeff [Semiring A] [SMul R A] (r : R) (n : ℕ) :
coeff n (binomialSeries A r) = Ring.choose r n • 1 :=
coeff_mk n fun n ↦ Ring.choose r n • 1
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries_coeff | null |
binomialSeries_constantCoeff [Ring A] [Algebra R A] (r : R) :
constantCoeff (binomialSeries A r) = 1 := by
simp [← coeff_zero_eq_constantCoeff_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries_constantCoeff | null |
binomialSeries_add [Ring A] [Algebra R A] (r s : R) :
binomialSeries A (r + s) = binomialSeries A r * binomialSeries A s := by
ext n
simp only [binomialSeries_coeff, Ring.add_choose_eq n (Commute.all r s), coeff_mul,
Algebra.mul_smul_comm, mul_one, sum_smul]
refine sum_congr rfl fun ab hab => ?_
rw [mul_comm, mul_smul]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries_add | null |
binomialSeries_nat [Ring A] [Algebra R A] (d : ℕ) :
binomialSeries A (d : R) = (1 + X) ^ d := by
ext n
have hright : (1 + X) ^ d = (((1 : Polynomial A) + (Polynomial.X)) ^ d).toPowerSeries := by
simp
rw [hright, Polynomial.coeff_coe, binomialSeries_coeff, Polynomial.coeff_one_add_X_pow]
simp [Ring.choose_natCast, Nat.cast_smul_eq_nsmul]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries_nat | null |
binomialSeries_zero [Ring A] [Algebra R A] :
binomialSeries A (0 : R) = (1 : A⟦X⟧) := by
simpa using binomialSeries_nat 0 | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | binomialSeries_zero | null |
rescale_neg_one_invOneSubPow [CommRing A] (d : ℕ) :
rescale (-1 : A) (invOneSubPow A d) = binomialSeries A (-d : ℤ) := by
ext n
rw [coeff_rescale, binomialSeries_coeff, ← Int.cast_negOnePow_natCast, ← zsmul_eq_mul]
cases d with
| zero =>
by_cases hn : n = 0 <;> simp [invOneSubPow, Ring.choose_zero_ite, hn]
| succ d =>
simp only [invOneSubPow, coeff_mk, Nat.cast_add, Nat.cast_one, neg_add_rev, Int.reduceNeg,
zsmul_eq_mul, mul_one]
rw [show (-1 : ℤ) + -d = -(d + 1) by abel, Ring.choose_neg, Nat.choose_symm_add, Units.smul_def,
show (d : ℤ) + 1 + n - 1 = d + n by cutsat, ← Nat.cast_add, Ring.choose_natCast]
norm_cast | lemma | RingTheory | [
"Mathlib.RingTheory.Binomial",
"Mathlib.RingTheory.PowerSeries.WellKnown"
] | Mathlib/RingTheory/PowerSeries/Binomial.lean | rescale_neg_one_invOneSubPow | null |
coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal (hf : ∀ i ≤ n, coeff i f ∈ I)
(hg : ∀ i ≤ n, coeff i g ∈ J) : ∀ i ≤ n, coeff i (f * g) ∈ I * J := fun i hi ↦ by
rw [coeff_mul]
exact Ideal.sum_mem _ fun p hp ↦ Ideal.mul_mem_mul
(hf _ ((Finset.antidiagonal.fst_le hp).trans hi))
(hg _ ((Finset.antidiagonal.snd_le hp).trans hi)) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal | null |
coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal' (hf : ∀ i, coeff i f ∈ I)
(hg : ∀ i, coeff i g ∈ J) : ∀ i, coeff i (f * g) ∈ I * J :=
fun i ↦ coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal i
(fun i _ ↦ hf i) (fun i _ ↦ hg i) i le_rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal' | null |
coeff_mul_mem_ideal_of_coeff_right_mem_ideal
(hg : ∀ i ≤ n, coeff i g ∈ I) : ∀ i ≤ n, coeff i (f * g) ∈ I := by
simpa using coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal (I := ⊤) (f := f) n (by simp) hg | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_of_coeff_right_mem_ideal | null |
coeff_mul_mem_ideal_of_coeff_right_mem_ideal'
(hg : ∀ i, coeff i g ∈ I) : ∀ i, coeff i (f * g) ∈ I := by
simpa using coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal' (I := ⊤) (f := f) (by simp) hg
variable [I.IsTwoSided] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_of_coeff_right_mem_ideal' | null |
coeff_mul_mem_ideal_of_coeff_left_mem_ideal
(hf : ∀ i ≤ n, coeff i f ∈ I) : ∀ i ≤ n, coeff i (f * g) ∈ I := by
simpa only [Ideal.IsTwoSided.mul_one] using
coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal (J := 1) (g := g) n hf (by simp) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_of_coeff_left_mem_ideal | null |
coeff_mul_mem_ideal_of_coeff_left_mem_ideal'
(hf : ∀ i, coeff i f ∈ I) : ∀ i, coeff i (f * g) ∈ I := by
simpa only [Ideal.IsTwoSided.mul_one] using
coeff_mul_mem_ideal_mul_ideal_of_coeff_mem_ideal' (J := 1) (g := g) hf (by simp) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/PowerSeries/CoeffMulMem.lean | coeff_mul_mem_ideal_of_coeff_left_mem_ideal' | null |
noncomputable derivativeFun (f : R⟦X⟧) : R⟦X⟧ := mk fun n ↦ coeff (n + 1) f * (n + 1) | def | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun | The formal derivative of a power series in one variable.
This is defined here as a function, but will be packaged as a
derivation `derivative` on `R⟦X⟧`. |
coeff_derivativeFun (f : R⟦X⟧) (n : ℕ) :
coeff n f.derivativeFun = coeff (n + 1) f * (n + 1) := by
rw [derivativeFun, coeff_mk] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | coeff_derivativeFun | null |
derivativeFun_coe (f : R[X]) : (f : R⟦X⟧).derivativeFun = derivative f := by
ext
rw [coeff_derivativeFun, coeff_coe, coeff_coe, coeff_derivative] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_coe | null |
derivativeFun_add (f g : R⟦X⟧) :
derivativeFun (f + g) = derivativeFun f + derivativeFun g := by
ext
rw [coeff_derivativeFun, map_add, map_add, coeff_derivativeFun,
coeff_derivativeFun, add_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_add | null |
derivativeFun_C (r : R) : derivativeFun (C r) = 0 := by
ext n
rw [coeff_derivativeFun, coeff_succ_C, zero_mul, (coeff n).map_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_C | null |
trunc_derivativeFun (f : R⟦X⟧) (n : ℕ) :
trunc n f.derivativeFun = derivative (trunc (n + 1) f) := by
ext d
rw [coeff_trunc]
split_ifs with h
· have : d + 1 < n + 1 := succ_lt_succ_iff.2 h
rw [coeff_derivativeFun, coeff_derivative, coeff_trunc, if_pos this]
· have : ¬d + 1 < n + 1 := by rwa [succ_lt_succ_iff]
rw [coeff_derivative, coeff_trunc, if_neg this, zero_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | trunc_derivativeFun | null |
private derivativeFun_coe_mul_coe (f g : R[X]) : derivativeFun (f * g : R⟦X⟧) =
f * derivative g + g * derivative f := by
rw [← coe_mul, derivativeFun_coe, derivative_mul,
add_comm, mul_comm _ g, ← coe_mul, ← coe_mul, Polynomial.coe_add] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_coe_mul_coe | null |
derivativeFun_mul (f g : R⟦X⟧) :
derivativeFun (f * g) = f • g.derivativeFun + g • f.derivativeFun := by
ext n
have h₁ : n < n + 1 := lt_succ_self n
have h₂ : n < n + 1 + 1 := Nat.lt_add_right _ h₁
rw [coeff_derivativeFun, map_add, coeff_mul_eq_coeff_trunc_mul_trunc _ _ (lt_succ_self _),
smul_eq_mul, smul_eq_mul, coeff_mul_eq_coeff_trunc_mul_trunc₂ g f.derivativeFun h₂ h₁,
coeff_mul_eq_coeff_trunc_mul_trunc₂ f g.derivativeFun h₂ h₁, trunc_derivativeFun,
trunc_derivativeFun, ← map_add, ← derivativeFun_coe_mul_coe, coeff_derivativeFun] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_mul | **Leibniz rule for formal power series**. |
derivativeFun_one : derivativeFun (1 : R⟦X⟧) = 0 := by
rw [← map_one C, derivativeFun_C (1 : R)] | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_one | null |
derivativeFun_smul (r : R) (f : R⟦X⟧) : derivativeFun (r • f) = r • derivativeFun f := by
rw [smul_eq_C_mul, smul_eq_C_mul, derivativeFun_mul, derivativeFun_C, smul_zero, add_zero,
smul_eq_mul]
variable (R) | theorem | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivativeFun_smul | null |
noncomputable derivative : Derivation R R⟦X⟧ R⟦X⟧ where
toFun := derivativeFun
map_add' := derivativeFun_add
map_smul' := derivativeFun_smul
map_one_eq_zero' := derivativeFun_one
leibniz' := derivativeFun_mul | def | RingTheory | [
"Mathlib.RingTheory.PowerSeries.Trunc",
"Mathlib.RingTheory.PowerSeries.Inverse",
"Mathlib.RingTheory.Derivation.Basic"
] | Mathlib/RingTheory/PowerSeries/Derivative.lean | derivative | The formal derivative of a formal power series |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.