File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

full_name: MvPowerSeries
code: /-- Multivariate formal power series, where `σ` is the index set of the variables
and `R` is the coefficient ring. -/
def MvPowerSeries (σ : Type*) (R : Type*) 
goal: Type (max u_2 u_1)

full_name: MvPowerSeries.instInhabited
code: instance [Inhabited R] : Inhabited (MvPowerSeries σ R) 
goal: Inhabited (MvPowerSeries σ R)

full_name: MvPowerSeries.instZero
code: instance [Zero R] : Zero (MvPowerSeries σ R) 
goal: Zero (MvPowerSeries σ R)

full_name: MvPowerSeries.instAddMonoid
code: instance [AddMonoid R] : AddMonoid (MvPowerSeries σ R) 
goal: AddMonoid (MvPowerSeries σ R)

full_name: MvPowerSeries.instAddGroup
code: instance [AddGroup R] : AddGroup (MvPowerSeries σ R) 
goal: AddGroup (MvPowerSeries σ R)

full_name: MvPowerSeries.instAddCommMonoid
code: instance [AddCommMonoid R] : AddCommMonoid (MvPowerSeries σ R) 
goal: AddCommMonoid (MvPowerSeries σ R)

full_name: MvPowerSeries.instAddCommGroup
code: instance [AddCommGroup R] : AddCommGroup (MvPowerSeries σ R) 
goal: AddCommGroup (MvPowerSeries σ R)

full_name: MvPowerSeries.instNontrivial
code: instance [Nontrivial R] : Nontrivial (MvPowerSeries σ R) 
goal: Nontrivial (MvPowerSeries σ R)

full_name: MvPowerSeries.instModule
code: instance {A} [Semiring R] [AddCommMonoid A] [Module R A] : Module R (MvPowerSeries σ A) 
goal: Module R (MvPowerSeries σ A)

full_name: MvPowerSeries.instIsScalarTower
code: instance {A S} [Semiring R] [Semiring S] [AddCommMonoid A] [Module R A] [Module S A] [SMul R S]
    [IsScalarTower R S A] : IsScalarTower R S (MvPowerSeries σ A) 
goal: IsScalarTower R S (MvPowerSeries σ A)

full_name: MvPowerSeries.monomial
code: /-- The `n`th monomial as multivariate formal power series:
  it is defined as the `R`-linear map from `R` to the semi-ring
  of multivariate formal power series associating to each `a`
  the map sending `n : σ →₀ ℕ` to the value `a`
  and sending all other `x : σ →₀ ℕ` different from `n` to `0`. -/
def monomial (n : σ →₀ ℕ) : R →ₗ[R] MvPowerSeries σ R 
goal: R →ₗ[R] MvPowerSeries σ R

full_name: MvPowerSeries.coeff
code: /-- The `n`th coefficient of a multivariate formal power series. -/
def coeff (n : σ →₀ ℕ) : MvPowerSeries σ R →ₗ[R] R 
goal: MvPowerSeries σ R →ₗ[R] R

full_name: MvPowerSeries.ext
code: /-- Two multivariate formal power series are equal if all their coefficients are equal. -/
@[ext]
theorem ext {φ ψ} (h : ∀ n : σ →₀ ℕ, coeff R n φ = coeff R n ψ) : φ = ψ 
goal: φ = ψ

full_name: MvPowerSeries.ext_iff
code: /-- Two multivariate formal power series are equal
 if and only if all their coefficients are equal. -/
theorem ext_iff {φ ψ : MvPowerSeries σ R} : φ = ψ ↔ ∀ n : σ →₀ ℕ, coeff R n φ = coeff R n ψ 
goal: φ = ψ ↔ ∀ (n : σ →₀ ℕ), (MvPowerSeries.coeff R n) φ = (MvPowerSeries.coeff R n) ψ

full_name: MvPowerSeries.monomial_def
code: theorem monomial_def [DecidableEq σ] (n : σ →₀ ℕ) :
    (monomial R n) = LinearMap.stdBasis R (fun _ ↦ R) n 
goal: MvPowerSeries.monomial R n = LinearMap.stdBasis R (fun x => R) n

full_name: MvPowerSeries.coeff_monomial
code: theorem coeff_monomial [DecidableEq σ] (m n : σ →₀ ℕ) (a : R) :
    coeff R m (monomial R n a) = if m = n then a else 0 
goal: (MvPowerSeries.coeff R m) ((MvPowerSeries.monomial R n) a) = if m = n then a else 0

full_name: MvPowerSeries.coeff_monomial_same
code: @[simp]
theorem coeff_monomial_same (n : σ →₀ ℕ) (a : R) : coeff R n (monomial R n a) = a 
goal: (MvPowerSeries.coeff R n) ((MvPowerSeries.monomial R n) a) = a

full_name: MvPowerSeries.coeff_monomial_ne
code: theorem coeff_monomial_ne {m n : σ →₀ ℕ} (h : m ≠ n) (a : R) : coeff R m (monomial R n a) = 0 
goal: (MvPowerSeries.coeff R m) ((MvPowerSeries.monomial R n) a) = 0

full_name: MvPowerSeries.eq_of_coeff_monomial_ne_zero
code: theorem eq_of_coeff_monomial_ne_zero {m n : σ →₀ ℕ} {a : R} (h : coeff R m (monomial R n a) ≠ 0) :
    m = n 
goal: m = n

full_name: MvPowerSeries.coeff_comp_monomial
code: @[simp]
theorem coeff_comp_monomial (n : σ →₀ ℕ) : (coeff R n).comp (monomial R n) = LinearMap.id 
goal: MvPowerSeries.coeff R n ∘ₗ MvPowerSeries.monomial R n = LinearMap.id

full_name: MvPowerSeries.coeff_zero
code: theorem coeff_zero (n : σ →₀ ℕ) : coeff R n (0 : MvPowerSeries σ R) = 0 
goal: (MvPowerSeries.coeff R n) 0 = 0

full_name: MvPowerSeries.instOne
code: instance : One (MvPowerSeries σ R) 
goal: One (MvPowerSeries σ R)

full_name: MvPowerSeries.coeff_one
code: theorem coeff_one [DecidableEq σ] : coeff R n (1 : MvPowerSeries σ R) = if n = 0 then 1 else 0 
goal: (MvPowerSeries.coeff R n) 1 = if n = 0 then 1 else 0

full_name: MvPowerSeries.coeff_zero_one
code: theorem coeff_zero_one : coeff R (0 : σ →₀ ℕ) 1 = 1 
goal: (MvPowerSeries.coeff R 0) 1 = 1

full_name: MvPowerSeries.monomial_zero_one
code: theorem monomial_zero_one : monomial R (0 : σ →₀ ℕ) 1 = 1 
goal: (MvPowerSeries.monomial R 0) 1 = 1

full_name: MvPowerSeries.instAddMonoidWithOne
code: instance : AddMonoidWithOne (MvPowerSeries σ R) 
goal: AddMonoidWithOne (MvPowerSeries σ R)

full_name: MvPowerSeries.instMul
code: instance : Mul (MvPowerSeries σ R) 
goal: Mul (MvPowerSeries σ R)

full_name: MvPowerSeries.coeff_mul
code: theorem coeff_mul [DecidableEq σ] :
    coeff R n (φ * ψ) = ∑ p ∈ antidiagonal n, coeff R p.1 φ * coeff R p.2 ψ 
goal: (MvPowerSeries.coeff R n) (φ * ψ) =
  ∑ p ∈ Finset.antidiagonal n, (MvPowerSeries.coeff R p.1) φ * (MvPowerSeries.coeff R p.2) ψ

full_name: MvPowerSeries.zero_mul
code: protected theorem zero_mul : (0 : MvPowerSeries σ R) * φ = 0 
goal: 0 * φ = 0

full_name: MvPowerSeries.mul_zero
code: protected theorem mul_zero : φ * 0 = 0 
goal: φ * 0 = 0

full_name: MvPowerSeries.coeff_monomial_mul
code: theorem coeff_monomial_mul (a : R) :
    coeff R m (monomial R n a * φ) = if n ≤ m then a * coeff R (m - n) φ else 0 
goal: (MvPowerSeries.coeff R m) ((MvPowerSeries.monomial R n) a * φ) =
  if n ≤ m then a * (MvPowerSeries.coeff R (m - n)) φ else 0

full_name: MvPowerSeries.coeff_mul_monomial
code: theorem coeff_mul_monomial (a : R) :
    coeff R m (φ * monomial R n a) = if n ≤ m then coeff R (m - n) φ * a else 0 
goal: (MvPowerSeries.coeff R m) (φ * (MvPowerSeries.monomial R n) a) =
  if n ≤ m then (MvPowerSeries.coeff R (m - n)) φ * a else 0

full_name: MvPowerSeries.coeff_add_monomial_mul
code: theorem coeff_add_monomial_mul (a : R) :
    coeff R (m + n) (monomial R m a * φ) = a * coeff R n φ 
goal: (MvPowerSeries.coeff R (m + n)) ((MvPowerSeries.monomial R m) a * φ) = a * (MvPowerSeries.coeff R n) φ

full_name: MvPowerSeries.coeff_add_mul_monomial
code: theorem coeff_add_mul_monomial (a : R) :
    coeff R (m + n) (φ * monomial R n a) = coeff R m φ * a 
goal: (MvPowerSeries.coeff R (m + n)) (φ * (MvPowerSeries.monomial R n) a) = (MvPowerSeries.coeff R m) φ * a

full_name: MvPowerSeries.commute_monomial
code: @[simp]
theorem commute_monomial {a : R} {n} :
    Commute φ (monomial R n a) ↔ ∀ m, Commute (coeff R m φ) a 
goal: Commute φ ((MvPowerSeries.monomial R n) a) ↔ ∀ (m : σ →₀ ℕ), Commute ((MvPowerSeries.coeff R m) φ) a

full_name: MvPowerSeries.one_mul
code: protected theorem one_mul : (1 : MvPowerSeries σ R) * φ = φ 
goal: 1 * φ = φ

full_name: MvPowerSeries.mul_one
code: protected theorem mul_one : φ * 1 = φ 
goal: φ * 1 = φ

full_name: MvPowerSeries.mul_add
code: protected theorem mul_add (φ₁ φ₂ φ₃ : MvPowerSeries σ R) : φ₁ * (φ₂ + φ₃) = φ₁ * φ₂ + φ₁ * φ₃ 
goal: φ₁ * (φ₂ + φ₃) = φ₁ * φ₂ + φ₁ * φ₃

full_name: MvPowerSeries.add_mul
code: protected theorem add_mul (φ₁ φ₂ φ₃ : MvPowerSeries σ R) : (φ₁ + φ₂) * φ₃ = φ₁ * φ₃ + φ₂ * φ₃ 
goal: (φ₁ + φ₂) * φ₃ = φ₁ * φ₃ + φ₂ * φ₃

full_name: MvPowerSeries.mul_assoc
code: protected theorem mul_assoc (φ₁ φ₂ φ₃ : MvPowerSeries σ R) : φ₁ * φ₂ * φ₃ = φ₁ * (φ₂ * φ₃) 
goal: φ₁ * φ₂ * φ₃ = φ₁ * (φ₂ * φ₃)

full_name: MvPowerSeries.instSemiring
code: instance : Semiring (MvPowerSeries σ R) 
goal: Semiring (MvPowerSeries σ R)

full_name: MvPowerSeries.instCommSemiring
code: instance [CommSemiring R] : CommSemiring (MvPowerSeries σ R) 
goal: CommSemiring (MvPowerSeries σ R)

full_name: MvPowerSeries.instRing
code: instance [Ring R] : Ring (MvPowerSeries σ R) 
goal: Ring (MvPowerSeries σ R)

full_name: MvPowerSeries.instCommRing
code: instance [CommRing R] : CommRing (MvPowerSeries σ R) 
goal: CommRing (MvPowerSeries σ R)

full_name: MvPowerSeries.monomial_mul_monomial
code: theorem monomial_mul_monomial (m n : σ →₀ ℕ) (a b : R) :
    monomial R m a * monomial R n b = monomial R (m + n) (a * b) 
goal: (MvPowerSeries.monomial R m) a * (MvPowerSeries.monomial R n) b = (MvPowerSeries.monomial R (m + n)) (a * b)

full_name: MvPowerSeries.C
code: /-- The constant multivariate formal power series. -/
def C : R →+* MvPowerSeries σ R 
goal: R →+* MvPowerSeries σ R

full_name: MvPowerSeries.monomial_zero_eq_C
code: @[simp]
theorem monomial_zero_eq_C : ⇑(monomial R (0 : σ →₀ ℕ)) = C σ R 
goal: ⇑(MvPowerSeries.monomial R 0) = ⇑(MvPowerSeries.C σ R)

full_name: MvPowerSeries.monomial_zero_eq_C_apply
code: theorem monomial_zero_eq_C_apply (a : R) : monomial R (0 : σ →₀ ℕ) a = C σ R a 
goal: (MvPowerSeries.monomial R 0) a = (MvPowerSeries.C σ R) a

full_name: MvPowerSeries.coeff_C
code: theorem coeff_C [DecidableEq σ] (n : σ →₀ ℕ) (a : R) :
    coeff R n (C σ R a) = if n = 0 then a else 0 
goal: (MvPowerSeries.coeff R n) ((MvPowerSeries.C σ R) a) = if n = 0 then a else 0

full_name: MvPowerSeries.coeff_zero_C
code: theorem coeff_zero_C (a : R) : coeff R (0 : σ →₀ ℕ) (C σ R a) = a 
goal: (MvPowerSeries.coeff R 0) ((MvPowerSeries.C σ R) a) = a

full_name: MvPowerSeries.X
code: /-- The variables of the multivariate formal power series ring. -/
def X (s : σ) : MvPowerSeries σ R 
goal: MvPowerSeries σ R

full_name: MvPowerSeries.coeff_X
code: theorem coeff_X [DecidableEq σ] (n : σ →₀ ℕ) (s : σ) :
    coeff R n (X s : MvPowerSeries σ R) = if n = single s 1 then 1 else 0 
goal: (MvPowerSeries.coeff R n) (MvPowerSeries.X s) = if n = Finsupp.single s 1 then 1 else 0

full_name: MvPowerSeries.coeff_index_single_X
code: theorem coeff_index_single_X [DecidableEq σ] (s t : σ) :
    coeff R (single t 1) (X s : MvPowerSeries σ R) = if t = s then 1 else 0 
goal: (MvPowerSeries.coeff R (Finsupp.single t 1)) (MvPowerSeries.X s) = if t = s then 1 else 0

full_name: MvPowerSeries.coeff_index_single_self_X
code: @[simp]
theorem coeff_index_single_self_X (s : σ) : coeff R (single s 1) (X s : MvPowerSeries σ R) = 1 
goal: (MvPowerSeries.coeff R (Finsupp.single s 1)) (MvPowerSeries.X s) = 1

full_name: MvPowerSeries.coeff_zero_X
code: theorem coeff_zero_X (s : σ) : coeff R (0 : σ →₀ ℕ) (X s : MvPowerSeries σ R) = 0 
goal: (MvPowerSeries.coeff R 0) (MvPowerSeries.X s) = 0

full_name: MvPowerSeries.commute_X
code: theorem commute_X (φ : MvPowerSeries σ R) (s : σ) : Commute φ (X s) 
goal: Commute φ (MvPowerSeries.X s)

full_name: MvPowerSeries.X_def
code: theorem X_def (s : σ) : X s = monomial R (single s 1) 1 
goal: MvPowerSeries.X s = (MvPowerSeries.monomial R (Finsupp.single s 1)) 1

full_name: MvPowerSeries.X_pow_eq
code: theorem X_pow_eq (s : σ) (n : ℕ) : (X s : MvPowerSeries σ R) ^ n = monomial R (single s n) 1 
goal: MvPowerSeries.X s ^ n = (MvPowerSeries.monomial R (Finsupp.single s n)) 1

full_name: MvPowerSeries.coeff_X_pow
code: theorem coeff_X_pow [DecidableEq σ] (m : σ →₀ ℕ) (s : σ) (n : ℕ) :
    coeff R m ((X s : MvPowerSeries σ R) ^ n) = if m = single s n then 1 else 0 
goal: (MvPowerSeries.coeff R m) (MvPowerSeries.X s ^ n) = if m = Finsupp.single s n then 1 else 0

full_name: MvPowerSeries.coeff_mul_C
code: @[simp]
theorem coeff_mul_C (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R) :
    coeff R n (φ * C σ R a) = coeff R n φ * a 
goal: (MvPowerSeries.coeff R n) (φ * (MvPowerSeries.C σ R) a) = (MvPowerSeries.coeff R n) φ * a

full_name: MvPowerSeries.coeff_C_mul
code: @[simp]
theorem coeff_C_mul (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R) :
    coeff R n (C σ R a * φ) = a * coeff R n φ 
goal: (MvPowerSeries.coeff R n) ((MvPowerSeries.C σ R) a * φ) = a * (MvPowerSeries.coeff R n) φ

full_name: MvPowerSeries.coeff_zero_mul_X
code: theorem coeff_zero_mul_X (φ : MvPowerSeries σ R) (s : σ) : coeff R (0 : σ →₀ ℕ) (φ * X s) = 0 
goal: (MvPowerSeries.coeff R 0) (φ * MvPowerSeries.X s) = 0

full_name: MvPowerSeries.coeff_zero_X_mul
code: theorem coeff_zero_X_mul (φ : MvPowerSeries σ R) (s : σ) : coeff R (0 : σ →₀ ℕ) (X s * φ) = 0 
goal: (MvPowerSeries.coeff R 0) (MvPowerSeries.X s * φ) = 0

full_name: MvPowerSeries.constantCoeff
code: /-- The constant coefficient of a formal power series. -/
def constantCoeff : MvPowerSeries σ R →+* R 
goal: MvPowerSeries σ R →+* R

full_name: MvPowerSeries.coeff_zero_eq_constantCoeff
code: @[simp]
theorem coeff_zero_eq_constantCoeff : ⇑(coeff R (0 : σ →₀ ℕ)) = constantCoeff σ R 
goal: ⇑(MvPowerSeries.coeff R 0) = ⇑(MvPowerSeries.constantCoeff σ R)

full_name: MvPowerSeries.coeff_zero_eq_constantCoeff_apply
code: theorem coeff_zero_eq_constantCoeff_apply (φ : MvPowerSeries σ R) :
    coeff R (0 : σ →₀ ℕ) φ = constantCoeff σ R φ 
goal: (MvPowerSeries.coeff R 0) φ = (MvPowerSeries.constantCoeff σ R) φ

full_name: MvPowerSeries.constantCoeff_C
code: @[simp]
theorem constantCoeff_C (a : R) : constantCoeff σ R (C σ R a) = a 
goal: (MvPowerSeries.constantCoeff σ R) ((MvPowerSeries.C σ R) a) = a

full_name: MvPowerSeries.constantCoeff_comp_C
code: @[simp]
theorem constantCoeff_comp_C : (constantCoeff σ R).comp (C σ R) = RingHom.id R 
goal: (MvPowerSeries.constantCoeff σ R).comp (MvPowerSeries.C σ R) = RingHom.id R

full_name: MvPowerSeries.constantCoeff_zero
code: theorem constantCoeff_zero : constantCoeff σ R 0 = 0 
goal: (MvPowerSeries.constantCoeff σ R) 0 = 0

full_name: MvPowerSeries.constantCoeff_one
code: theorem constantCoeff_one : constantCoeff σ R 1 = 1 
goal: (MvPowerSeries.constantCoeff σ R) 1 = 1

full_name: MvPowerSeries.constantCoeff_X
code: @[simp]
theorem constantCoeff_X (s : σ) : constantCoeff σ R (X s) = 0 
goal: (MvPowerSeries.constantCoeff σ R) (MvPowerSeries.X s) = 0

full_name: MvPowerSeries.isUnit_constantCoeff
code: /-- If a multivariate formal power series is invertible,
 then so is its constant coefficient. -/
theorem isUnit_constantCoeff (φ : MvPowerSeries σ R) (h : IsUnit φ) :
    IsUnit (constantCoeff σ R φ) 
goal: IsUnit ((MvPowerSeries.constantCoeff σ R) φ)

full_name: MvPowerSeries.coeff_smul
code: theorem coeff_smul (f : MvPowerSeries σ R) (n) (a : R) : coeff _ n (a • f) = a * coeff _ n f 
goal: (MvPowerSeries.coeff R n) (a • f) = a * (MvPowerSeries.coeff R n) f

full_name: MvPowerSeries.smul_eq_C_mul
code: theorem smul_eq_C_mul (f : MvPowerSeries σ R) (a : R) : a • f = C σ R a * f 
goal: a • f = (MvPowerSeries.C σ R) a * f

full_name: MvPowerSeries.X_inj
code: theorem X_inj [Nontrivial R] {s t : σ} : (X s : MvPowerSeries σ R) = X t ↔ s = t 
goal: MvPowerSeries.X s = MvPowerSeries.X t ↔ s = t

full_name: MvPowerSeries.map
code: /-- The map between multivariate formal power series induced by a map on the coefficients. -/
def map : MvPowerSeries σ R →+* MvPowerSeries σ S 
goal: MvPowerSeries σ R →+* MvPowerSeries σ S

full_name: MvPowerSeries.map_id
code: @[simp]
theorem map_id : map σ (RingHom.id R) = RingHom.id _ 
goal: MvPowerSeries.map σ (RingHom.id R) = RingHom.id (MvPowerSeries σ R)

full_name: MvPowerSeries.map_comp
code: theorem map_comp : map σ (g.comp f) = (map σ g).comp (map σ f) 
goal: MvPowerSeries.map σ (g.comp f) = (MvPowerSeries.map σ g).comp (MvPowerSeries.map σ f)

full_name: MvPowerSeries.coeff_map
code: @[simp]
theorem coeff_map (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) : coeff S n (map σ f φ) = f (coeff R n φ) 
goal: (MvPowerSeries.coeff S n) ((MvPowerSeries.map σ f) φ) = f ((MvPowerSeries.coeff R n) φ)

full_name: MvPowerSeries.constantCoeff_map
code: @[simp]
theorem constantCoeff_map (φ : MvPowerSeries σ R) :
    constantCoeff σ S (map σ f φ) = f (constantCoeff σ R φ) 
goal: (MvPowerSeries.constantCoeff σ S) ((MvPowerSeries.map σ f) φ) = f ((MvPowerSeries.constantCoeff σ R) φ)

full_name: MvPowerSeries.map_monomial
code: @[simp]
theorem map_monomial (n : σ →₀ ℕ) (a : R) : map σ f (monomial R n a) = monomial S n (f a) 
goal: (MvPowerSeries.map σ f) ((MvPowerSeries.monomial R n) a) = (MvPowerSeries.monomial S n) (f a)

full_name: MvPowerSeries.map_C
code: @[simp]
theorem map_C (a : R) : map σ f (C σ R a) = C σ S (f a) 
goal: (MvPowerSeries.map σ f) ((MvPowerSeries.C σ R) a) = (MvPowerSeries.C σ S) (f a)

full_name: MvPowerSeries.map_X
code: @[simp]
theorem map_X (s : σ) : map σ f (X s) = X s 
goal: (MvPowerSeries.map σ f) (MvPowerSeries.X s) = MvPowerSeries.X s

full_name: MvPowerSeries.X_pow_dvd_iff
code: theorem X_pow_dvd_iff {s : σ} {n : ℕ} {φ : MvPowerSeries σ R} :
    (X s : MvPowerSeries σ R) ^ n ∣ φ ↔ ∀ m : σ →₀ ℕ, m s < n → coeff R m φ = 0 
goal: MvPowerSeries.X s ^ n ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s < n → (MvPowerSeries.coeff R m) φ = 0

full_name: MvPowerSeries.X_dvd_iff
code: theorem X_dvd_iff {s : σ} {φ : MvPowerSeries σ R} :
    (X s : MvPowerSeries σ R) ∣ φ ↔ ∀ m : σ →₀ ℕ, m s = 0 → coeff R m φ = 0 
goal: MvPowerSeries.X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s = 0 → (MvPowerSeries.coeff R m) φ = 0

full_name: MvPowerSeries.coeff_prod
code: /-- Coefficients of a product of power series -/
theorem coeff_prod [DecidableEq σ]
    (f : ι → MvPowerSeries σ R) (d : σ →₀ ℕ) (s : Finset ι) :
    coeff R d (∏ j ∈ s, f j) =
      ∑ l ∈ finsuppAntidiag s d,
        ∏ i ∈ s, coeff R (l i) (f i) 
goal: (MvPowerSeries.coeff R d) (∏ j ∈ s, f j) = ∑ l ∈ s.finsuppAntidiag d, ∏ i ∈ s, (MvPowerSeries.coeff R (l i)) (f i)

full_name: MvPowerSeries.coeff_pow
code: /-- The `d`th coefficient of a power of a multivariate power series
is the sum, indexed by `finsuppAntidiag (Finset.range n) d`, of products of coefficients  -/
theorem coeff_pow [DecidableEq σ] (f : MvPowerSeries σ R) {n : ℕ} (d : σ →₀ ℕ) :
    coeff R d (f ^ n) =
      ∑ l in finsuppAntidiag (Finset.range n) d,
        ∏ i in Finset.range n, coeff R (l i) f 
goal: (MvPowerSeries.coeff R d) (f ^ n) =
  ∑ l ∈ (Finset.range n).finsuppAntidiag d, ∏ i ∈ Finset.range n, (MvPowerSeries.coeff R (l i)) f

full_name: MvPowerSeries.coeff_eq_zero_of_constantCoeff_nilpotent
code: /-- Vanishing of coefficients of powers of multivariate power series
when the constant coefficient is nilpotent
[N. Bourbaki, *Algebra {II}*, Chapter 4, §4, n°2, proposition 3][bourbaki1981] -/
theorem coeff_eq_zero_of_constantCoeff_nilpotent [DecidableEq σ]
    {f : MvPowerSeries σ R} {m : ℕ} (hf : constantCoeff σ R f ^ m = 0)
    {d : σ →₀ ℕ} {n : ℕ} (hn : m + degree d ≤ n) : coeff R d (f ^ n) = 0 
goal: (MvPowerSeries.coeff R d) (f ^ n) = 0

full_name: MvPowerSeries.instAlgebra
code: instance : Algebra R (MvPowerSeries σ A) 
goal: Algebra R (MvPowerSeries σ A)

full_name: MvPowerSeries.c_eq_algebraMap
code: theorem c_eq_algebraMap : C σ R = algebraMap R (MvPowerSeries σ R) 
goal: MvPowerSeries.C σ R = algebraMap R (MvPowerSeries σ R)

full_name: MvPowerSeries.algebraMap_apply
code: theorem algebraMap_apply {r : R} :
    algebraMap R (MvPowerSeries σ A) r = C σ A (algebraMap R A r) 
goal: (algebraMap R (MvPowerSeries σ A)) r = (MvPowerSeries.C σ A) ((algebraMap R A) r)

full_name: MvPowerSeries.instNontrivialSubalgebraOfNonempty
code: instance [Nonempty σ] [Nontrivial R] : Nontrivial (Subalgebra R (MvPowerSeries σ R)) 
goal: Nontrivial (Subalgebra R (MvPowerSeries σ R))

full_name: MvPolynomial.toMvPowerSeries
code: /-- The natural inclusion from multivariate polynomials into multivariate formal power series. -/
@[coe]
def toMvPowerSeries : MvPolynomial σ R → MvPowerSeries σ R 
goal: MvPolynomial σ R → MvPowerSeries σ R

full_name: MvPolynomial.coeToMvPowerSeries
code: /-- The natural inclusion from multivariate polynomials into multivariate formal power series. -/
instance coeToMvPowerSeries : Coe (MvPolynomial σ R) (MvPowerSeries σ R) 
goal: Coe (MvPolynomial σ R) (MvPowerSeries σ R)

full_name: MvPolynomial.coe_def
code: theorem coe_def : (φ : MvPowerSeries σ R) = fun n => coeff n φ 
goal: ↑φ = fun n => MvPolynomial.coeff n φ

full_name: MvPolynomial.coeff_coe
code: @[simp, norm_cast]
theorem coeff_coe (n : σ →₀ ℕ) : MvPowerSeries.coeff R n ↑φ = coeff n φ 
goal: (MvPowerSeries.coeff R n) ↑φ = MvPolynomial.coeff n φ

full_name: MvPolynomial.coe_monomial
code: @[simp, norm_cast]
theorem coe_monomial (n : σ →₀ ℕ) (a : R) :
    (monomial n a : MvPowerSeries σ R) = MvPowerSeries.monomial R n a 
goal: ↑((MvPolynomial.monomial n) a) = (MvPowerSeries.monomial R n) a

full_name: MvPolynomial.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ((0 : MvPolynomial σ R) : MvPowerSeries σ R) = 0 
goal: ↑0 = 0

full_name: MvPolynomial.coe_one
code: @[simp, norm_cast]
theorem coe_one : ((1 : MvPolynomial σ R) : MvPowerSeries σ R) = 1 
goal: ↑1 = 1

full_name: MvPolynomial.coe_add
code: @[simp, norm_cast]
theorem coe_add : ((φ + ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ + ψ 
goal: ↑(φ + ψ) = ↑φ + ↑ψ

full_name: MvPolynomial.coe_mul
code: @[simp, norm_cast]
theorem coe_mul : ((φ * ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ * ψ 
goal: ↑(φ * ψ) = ↑φ * ↑ψ

full_name: MvPolynomial.coe_C
code: @[simp, norm_cast]
theorem coe_C (a : R) : ((C a : MvPolynomial σ R) : MvPowerSeries σ R) = MvPowerSeries.C σ R a 
goal: ↑(MvPolynomial.C a) = (MvPowerSeries.C σ R) a

full_name: MvPolynomial.coe_X
code: @[simp, norm_cast]
theorem coe_X (s : σ) : ((X s : MvPolynomial σ R) : MvPowerSeries σ R) = MvPowerSeries.X s 
goal: ↑(MvPolynomial.X s) = MvPowerSeries.X s

full_name: MvPolynomial.coe_injective
code: theorem coe_injective : Function.Injective (Coe.coe : MvPolynomial σ R → MvPowerSeries σ R) 
goal: Function.Injective Coe.coe

full_name: MvPolynomial.coe_inj
code: @[simp, norm_cast]
theorem coe_inj : (φ : MvPowerSeries σ R) = ψ ↔ φ = ψ 
goal: ↑φ = ↑ψ ↔ φ = ψ

full_name: MvPolynomial.coe_eq_zero_iff
code: @[simp]
theorem coe_eq_zero_iff : (φ : MvPowerSeries σ R) = 0 ↔ φ = 0 
goal: ↑φ = 0 ↔ φ = 0

full_name: MvPolynomial.coe_eq_one_iff
code: @[simp]
theorem coe_eq_one_iff : (φ : MvPowerSeries σ R) = 1 ↔ φ = 1 
goal: ↑φ = 1 ↔ φ = 1

full_name: MvPolynomial.coeToMvPowerSeries.ringHom
code: /-- The coercion from multivariate polynomials to multivariate power series
as a ring homomorphism.
-/
def coeToMvPowerSeries.ringHom : MvPolynomial σ R →+* MvPowerSeries σ R 
goal: MvPolynomial σ R →+* MvPowerSeries σ R

full_name: MvPolynomial.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (n : ℕ) :
    ((φ ^ n : MvPolynomial σ R) : MvPowerSeries σ R) = (φ : MvPowerSeries σ R) ^ n 
goal: ↑(φ ^ n) = ↑φ ^ n

full_name: MvPolynomial.coeToMvPowerSeries.ringHom_apply
code: @[simp]
theorem coeToMvPowerSeries.ringHom_apply : coeToMvPowerSeries.ringHom φ = φ 
goal: MvPolynomial.coeToMvPowerSeries.ringHom φ = ↑φ

full_name: MvPolynomial.coeToMvPowerSeries.algHom
code: /-- The coercion from multivariate polynomials to multivariate power series
as an algebra homomorphism.
-/
def coeToMvPowerSeries.algHom : MvPolynomial σ R →ₐ[R] MvPowerSeries σ A 
goal: MvPolynomial σ R →ₐ[R] MvPowerSeries σ A

full_name: MvPolynomial.coeToMvPowerSeries.algHom_apply
code: @[simp]
theorem coeToMvPowerSeries.algHom_apply :
    coeToMvPowerSeries.algHom A φ = MvPowerSeries.map σ (algebraMap R A) ↑φ 
goal: (MvPolynomial.coeToMvPowerSeries.algHom A) φ = (MvPowerSeries.map σ (algebraMap R A)) ↑φ

full_name: MvPowerSeries.algebraMvPolynomial
code: instance algebraMvPolynomial : Algebra (MvPolynomial σ R) (MvPowerSeries σ A) 
goal: Algebra (MvPolynomial σ R) (MvPowerSeries σ A)

full_name: MvPowerSeries.algebraMvPowerSeries
code: instance algebraMvPowerSeries : Algebra (MvPowerSeries σ R) (MvPowerSeries σ A) 
goal: Algebra (MvPowerSeries σ R) (MvPowerSeries σ A)

full_name: MvPowerSeries.algebraMap_apply'
code: theorem algebraMap_apply' (p : MvPolynomial σ R) :
    algebraMap (MvPolynomial σ R) (MvPowerSeries σ A) p = map σ (algebraMap R A) p 
goal: (algebraMap (MvPolynomial σ R) (MvPowerSeries σ A)) p = (MvPowerSeries.map σ (algebraMap R A)) ↑p

full_name: MvPowerSeries.algebraMap_apply''
code: theorem algebraMap_apply'' :
    algebraMap (MvPowerSeries σ R) (MvPowerSeries σ A) f = map σ (algebraMap R A) f 
goal: (algebraMap (MvPowerSeries σ R) (MvPowerSeries σ A)) f = (MvPowerSeries.map σ (algebraMap R A)) f