File: Mathlib/RingTheory/LaurentSeries.lean

full_name: LaurentSeries
code: /-- A `LaurentSeries` is implemented as a `HahnSeries` with value group `ℤ`. -/
abbrev LaurentSeries (R : Type u) [Zero R] 
goal: Type u

full_name: LaurentSeries.hasseDeriv
code: /-- The Hasse derivative of Laurent series, as a linear map. -/
@[simps]
def hasseDeriv (R : Type*) {V : Type*} [AddCommGroup V] [Semiring R] [Module R V] (k : ℕ) :
    LaurentSeries V →ₗ[R] LaurentSeries V 
goal: LaurentSeries V →ₗ[R] LaurentSeries V

full_name: LaurentSeries.hasseDeriv_apply
code: /-- The Hasse derivative of Laurent series, as a linear map. -/
@[simps]
def hasseDeriv (R : Type*) {V : Type*} [AddCommGroup V] [Semiring R] [Module R V] (k : ℕ) :
    LaurentSeries V →ₗ[R] LaurentSeries V 
goal: (LaurentSeries.hasseDeriv R k) f = HahnSeries.ofSuppBddBelow (fun n => Ring.choose (n + ↑k) k • f.coeff (n + ↑k)) ⋯

full_name: LaurentSeries.hasseDeriv_coeff
code: theorem hasseDeriv_coeff (k : ℕ) (f : LaurentSeries V) (n : ℤ) :
    (hasseDeriv R k f).coeff n = Ring.choose (n + k) k • f.coeff (n + k) 
goal: ((LaurentSeries.hasseDeriv R k) f).coeff n = Ring.choose (n + ↑k) k • f.coeff (n + ↑k)

full_name: LaurentSeries.instCoePowerSeries
code: instance : Coe (PowerSeries R) (LaurentSeries R) 
goal: Coe (PowerSeries R) (LaurentSeries R)

full_name: LaurentSeries.coeff_coe_powerSeries
code: @[simp]
theorem coeff_coe_powerSeries (x : PowerSeries R) (n : ℕ) :
    HahnSeries.coeff (x : LaurentSeries R) n = PowerSeries.coeff R n x 
goal: ((HahnSeries.ofPowerSeries ℤ R) x).coeff ↑n = (PowerSeries.coeff R n) x

full_name: LaurentSeries.powerSeriesPart
code: /-- This is a power series that can be multiplied by an integer power of `X` to give our
  Laurent series. If the Laurent series is nonzero, `powerSeriesPart` has a nonzero
  constant term.  -/
def powerSeriesPart (x : LaurentSeries R) : PowerSeries R 
goal: PowerSeries R

full_name: LaurentSeries.powerSeriesPart_coeff
code: @[simp]
theorem powerSeriesPart_coeff (x : LaurentSeries R) (n : ℕ) :
    PowerSeries.coeff R n x.powerSeriesPart = x.coeff (x.order + n) 
goal: (PowerSeries.coeff R n) x.powerSeriesPart = x.coeff (HahnSeries.order x + ↑n)

full_name: LaurentSeries.powerSeriesPart_zero
code: @[simp]
theorem powerSeriesPart_zero : powerSeriesPart (0 : LaurentSeries R) = 0 
goal: LaurentSeries.powerSeriesPart 0 = 0

full_name: LaurentSeries.powerSeriesPart_eq_zero
code: @[simp]
theorem powerSeriesPart_eq_zero (x : LaurentSeries R) : x.powerSeriesPart = 0 ↔ x = 0 
goal: x.powerSeriesPart = 0 ↔ x = 0

full_name: LaurentSeries.single_order_mul_powerSeriesPart
code: @[simp]
theorem single_order_mul_powerSeriesPart (x : LaurentSeries R) :
    (single x.order 1 : LaurentSeries R) * x.powerSeriesPart = x 
goal: (HahnSeries.single (HahnSeries.order x)) 1 * (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = x

full_name: LaurentSeries.ofPowerSeries_powerSeriesPart
code: theorem ofPowerSeries_powerSeriesPart (x : LaurentSeries R) :
    ofPowerSeries ℤ R x.powerSeriesPart = single (-x.order) 1 * x 
goal: (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = (HahnSeries.single (-HahnSeries.order x)) 1 * x

full_name: LaurentSeries.instAlgebraPowerSeries
code: instance [CommSemiring R] : Algebra (PowerSeries R) (LaurentSeries R) 
goal: Algebra (PowerSeries R) (LaurentSeries R)

full_name: LaurentSeries.coe_algebraMap
code: @[simp]
theorem coe_algebraMap [CommSemiring R] :
    ⇑(algebraMap (PowerSeries R) (LaurentSeries R)) = HahnSeries.ofPowerSeries ℤ R 
goal: ⇑(algebraMap (PowerSeries R) (LaurentSeries R)) = ⇑(HahnSeries.ofPowerSeries ℤ R)

full_name: LaurentSeries.of_powerSeries_localization
code: /-- The localization map from power series to Laurent series. -/
@[simps (config := { rhsMd := .all, simpRhs := true })]
instance of_powerSeries_localization [CommRing R] :
    IsLocalization (Submonoid.powers (PowerSeries.X : PowerSeries R)) (LaurentSeries R) 
goal: IsLocalization (Submonoid.powers PowerSeries.X) (LaurentSeries R)

full_name: LaurentSeries.instIsFractionRingPowerSeries
code: instance {K : Type*} [Field K] : IsFractionRing (PowerSeries K) (LaurentSeries K) 
goal: IsFractionRing (PowerSeries K) (LaurentSeries K)

full_name: PowerSeries.coe_zero
code: @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_zero : ((0 : PowerSeries R) : LaurentSeries R) = 0 
goal: (HahnSeries.ofPowerSeries ℤ R) 0 = 0

full_name: PowerSeries.coe_one
code: @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_one : ((1 : PowerSeries R) : LaurentSeries R) = 1 
goal: (HahnSeries.ofPowerSeries ℤ R) 1 = 1

full_name: PowerSeries.coe_add
code: @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_add : ((f + g : PowerSeries R) : LaurentSeries R) = f + g 
goal: (HahnSeries.ofPowerSeries ℤ R) (f + g) = (HahnSeries.ofPowerSeries ℤ R) f + (HahnSeries.ofPowerSeries ℤ R) g

full_name: PowerSeries.coe_sub
code: @[norm_cast]
theorem coe_sub : ((f' - g' : PowerSeries R') : LaurentSeries R') = f' - g' 
goal: (HahnSeries.ofPowerSeries ℤ R') (f' - g') = (HahnSeries.ofPowerSeries ℤ R') f' - (HahnSeries.ofPowerSeries ℤ R') g'

full_name: PowerSeries.coe_neg
code: @[norm_cast]
theorem coe_neg : ((-f' : PowerSeries R') : LaurentSeries R') = -f' 
goal: (HahnSeries.ofPowerSeries ℤ R') (-f') = -(HahnSeries.ofPowerSeries ℤ R') f'

full_name: PowerSeries.coe_mul
code: @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_mul : ((f * g : PowerSeries R) : LaurentSeries R) = f * g 
goal: (HahnSeries.ofPowerSeries ℤ R) (f * g) = (HahnSeries.ofPowerSeries ℤ R) f * (HahnSeries.ofPowerSeries ℤ R) g

full_name: PowerSeries.coeff_coe
code: theorem coeff_coe (i : ℤ) :
    ((f : PowerSeries R) : LaurentSeries R).coeff i =
      if i < 0 then 0 else PowerSeries.coeff R i.natAbs f 
goal: ((HahnSeries.ofPowerSeries ℤ R) f).coeff i = if i < 0 then 0 else (PowerSeries.coeff R i.natAbs) f

full_name: PowerSeries.coe_C
code: theorem coe_C (r : R) : ((C R r : PowerSeries R) : LaurentSeries R) = HahnSeries.C r 
goal: (HahnSeries.ofPowerSeries ℤ R) ((PowerSeries.C R) r) = HahnSeries.C r

full_name: PowerSeries.coe_X
code: theorem coe_X : ((X : PowerSeries R) : LaurentSeries R) = single 1 1 
goal: (HahnSeries.ofPowerSeries ℤ R) PowerSeries.X = (HahnSeries.single 1) 1

full_name: PowerSeries.coe_smul
code: @[simp, norm_cast]
theorem coe_smul {S : Type*} [Semiring S] [Module R S] (r : R) (x : PowerSeries S) :
    ((r • x : PowerSeries S) : LaurentSeries S) = r • (ofPowerSeries ℤ S x) 
goal: (HahnSeries.ofPowerSeries ℤ S) (r • x) = r • (HahnSeries.ofPowerSeries ℤ S) x

full_name: PowerSeries.coe_pow
code: @[norm_cast]
theorem coe_pow (n : ℕ) : ((f ^ n : PowerSeries R) : LaurentSeries R) = (ofPowerSeries ℤ R f) ^ n 
goal: (HahnSeries.ofPowerSeries ℤ R) (f ^ n) = (HahnSeries.ofPowerSeries ℤ R) f ^ n

full_name: RatFunc.coeAlgHom
code: /-- The coercion `RatFunc F → LaurentSeries F` as bundled alg hom. -/
def coeAlgHom (F : Type u) [Field F] : RatFunc F →ₐ[F[X]] LaurentSeries F 
goal: RatFunc F →ₐ[F[X]] LaurentSeries F

full_name: RatFunc.coeToLaurentSeries_fun
code: /-- The coercion `RatFunc F → LaurentSeries F` as a function.

This is the implementation of `coeToLaurentSeries`.
-/
@[coe]
def coeToLaurentSeries_fun {F : Type u} [Field F] : RatFunc F → LaurentSeries F 
goal: RatFunc F → LaurentSeries F

full_name: RatFunc.coeToLaurentSeries
code: instance coeToLaurentSeries : Coe (RatFunc F) (LaurentSeries F) 
goal: Coe (RatFunc F) (LaurentSeries F)

full_name: RatFunc.coe_def
code: theorem coe_def : (f : LaurentSeries F) = coeAlgHom F f 
goal: ↑f = (RatFunc.coeAlgHom F) f

full_name: RatFunc.coe_num_denom
code: theorem coe_num_denom : (f : LaurentSeries F) = f.num / f.denom 
goal: ↑f = (HahnSeries.ofPowerSeries ℤ F) ↑f.num / (HahnSeries.ofPowerSeries ℤ F) ↑f.denom

full_name: RatFunc.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : RatFunc F → LaurentSeries F) 
goal: Function.Injective RatFunc.coeToLaurentSeries_fun

full_name: RatFunc.coe_apply
code: @[simp]
theorem coe_apply : coeAlgHom F f = f 
goal: (RatFunc.coeAlgHom F) f = ↑f

full_name: RatFunc.coe_coe
code: theorem coe_coe (P : Polynomial F) : ((P : PowerSeries F) : LaurentSeries F) = (P : RatFunc F) 
goal: (HahnSeries.ofPowerSeries ℤ F) ↑P = ↑↑P

full_name: RatFunc.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ((0 : RatFunc F) : LaurentSeries F) = 0 
goal: ↑0 = 0

full_name: RatFunc.coe_ne_zero
code: theorem coe_ne_zero {f : Polynomial F} (hf : f ≠ 0) : (↑f : PowerSeries F) ≠ 0 
goal: ↑f ≠ 0

full_name: RatFunc.coe_one
code: @[simp, norm_cast]
theorem coe_one : ((1 : RatFunc F) : LaurentSeries F) = 1 
goal: ↑1 = 1

full_name: RatFunc.coe_add
code: @[simp, norm_cast]
theorem coe_add : ((f + g : RatFunc F) : LaurentSeries F) = f + g 
goal: ↑(f + g) = ↑f + ↑g

full_name: RatFunc.coe_sub
code: @[simp, norm_cast]
theorem coe_sub : ((f - g : RatFunc F) : LaurentSeries F) = f - g 
goal: ↑(f - g) = ↑f - ↑g

full_name: RatFunc.coe_neg
code: @[simp, norm_cast]
theorem coe_neg : ((-f : RatFunc F) : LaurentSeries F) = -f 
goal: ↑(-f) = -↑f

full_name: RatFunc.coe_mul
code: @[simp, norm_cast]
theorem coe_mul : ((f * g : RatFunc F) : LaurentSeries F) = f * g 
goal: ↑(f * g) = ↑f * ↑g

full_name: RatFunc.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (n : ℕ) : ((f ^ n : RatFunc F) : LaurentSeries F) = (f : LaurentSeries F) ^ n 
goal: ↑(f ^ n) = ↑f ^ n

full_name: RatFunc.coe_div
code: @[simp, norm_cast]
theorem coe_div :
    ((f / g : RatFunc F) : LaurentSeries F) = (f : LaurentSeries F) / (g : LaurentSeries F) 
goal: ↑(f / g) = ↑f / ↑g

full_name: RatFunc.coe_C
code: @[simp, norm_cast]
theorem coe_C (r : F) : ((RatFunc.C r : RatFunc F) : LaurentSeries F) = HahnSeries.C r 
goal: ↑(RatFunc.C r) = HahnSeries.C r

full_name: RatFunc.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (r : F) : ((r • f : RatFunc F) : LaurentSeries F) = r • (f : LaurentSeries F) 
goal: ↑(r • f) = r • ↑f

full_name: RatFunc.coe_X
code: @[simp]
theorem coe_X : ((X : RatFunc F) : LaurentSeries F) = single 1 1 
goal: ↑RatFunc.X = (HahnSeries.single 1) 1

full_name: RatFunc.single_one_eq_pow
code: theorem single_one_eq_pow {R : Type _} [Ring R] (n : ℕ) :
    single (n : ℤ) (1 : R) = single (1 : ℤ) 1 ^ n 
goal: (HahnSeries.single ↑n) 1 = (HahnSeries.single 1) 1 ^ n

full_name: RatFunc.single_inv
code: theorem single_inv (d : ℤ) {α : F} (hα : α ≠ 0) :
    single (-d) (α⁻¹ : F) = (single (d : ℤ) (α : F))⁻¹ 
goal: (HahnSeries.single (-d)) α⁻¹ = ((HahnSeries.single d) α)⁻¹

full_name: RatFunc.single_zpow
code: theorem single_zpow (n : ℤ) :
    single (n : ℤ) (1 : F) = single (1 : ℤ) 1 ^ n 
goal: (HahnSeries.single n) 1 = (HahnSeries.single 1) 1 ^ n

full_name: RatFunc.instAlgebraLaurentSeries
code: instance : Algebra (RatFunc F) (LaurentSeries F) 
goal: Algebra (RatFunc F) (LaurentSeries F)

full_name: RatFunc.algebraMap_apply_div
code: theorem algebraMap_apply_div :
    algebraMap (RatFunc F) (LaurentSeries F) (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap F[X] (LaurentSeries F) p / algebraMap _ _ q 
goal: (algebraMap (RatFunc F) (LaurentSeries F)) ((algebraMap F[X] (RatFunc F)) p / (algebraMap F[X] (RatFunc F)) q) =
  (algebraMap F[X] (LaurentSeries F)) p / (algebraMap F[X] (LaurentSeries F)) q

full_name: RatFunc.instIsScalarTowerPolynomialLaurentSeries
code: instance : IsScalarTower F[X] (RatFunc F) (LaurentSeries F) 
goal: IsScalarTower F[X] (RatFunc F) (LaurentSeries F)

full_name: PowerSeries.idealX
code: /-- The prime ideal `(X)` of `PowerSeries K`, when `K` is a field, as a term of the
`HeightOneSpectrum`. -/
def idealX : IsDedekindDomain.HeightOneSpectrum K⟦X⟧ 
goal: IsDedekindDomain.HeightOneSpectrum (PowerSeries K)

full_name: PowerSeries.intValuation_eq_of_coe
code: theorem intValuation_eq_of_coe (P : K[X]) :
    (Polynomial.idealX K).intValuation P = (idealX K).intValuation (P : K⟦X⟧) 
goal: (Polynomial.idealX K).intValuation P = (PowerSeries.idealX K).intValuation ↑P

full_name: PowerSeries.intValuation_X
code: /-- The integral valuation of the power series `X : K⟦X⟧` equals `(ofAdd -1) : ℤₘ₀`-/
@[simp]
theorem intValuation_X : (idealX K).intValuationDef X = ↑(Multiplicative.ofAdd (-1 : ℤ)) 
goal: (PowerSeries.idealX K).intValuationDef PowerSeries.X = ↑(Multiplicative.ofAdd (-1))

full_name: RatFunc.valuation_eq_LaurentSeries_valuation
code: theorem valuation_eq_LaurentSeries_valuation (P : RatFunc K) :
    (Polynomial.idealX K).valuation P = (PowerSeries.idealX K).valuation (P : LaurentSeries K) 
goal: (Polynomial.idealX K).valuation P = (PowerSeries.idealX K).valuation ↑P

full_name: LaurentSeries.instValuedWithZeroMultiplicativeInt
code: instance : Valued (LaurentSeries K) ℤₘ₀ 
goal: Valued (LaurentSeries K) (WithZero (Multiplicative ℤ))

full_name: LaurentSeries.valuation_X_pow
code: theorem valuation_X_pow (s : ℕ) :
    Valued.v (((X : K⟦X⟧) : LaurentSeries K) ^ s) = Multiplicative.ofAdd (-(s : ℤ)) 
goal: Valued.v ((HahnSeries.ofPowerSeries ℤ K) PowerSeries.X ^ s) = ↑(Multiplicative.ofAdd (-↑s))

full_name: LaurentSeries.valuation_single_zpow
code: theorem valuation_single_zpow (s : ℤ) :
    Valued.v (HahnSeries.single s (1 : K) : LaurentSeries K) =
      Multiplicative.ofAdd (-(s : ℤ)) 
goal: Valued.v ((HahnSeries.single s) 1) = ↑(Multiplicative.ofAdd (-s))

full_name: LaurentSeries.coeff_zero_of_lt_intValuation
code: theorem coeff_zero_of_lt_intValuation {n d : ℕ} {f : K⟦X⟧}
    (H : Valued.v (f : LaurentSeries K) ≤ Multiplicative.ofAdd (-d : ℤ)) :
    n < d → coeff K n f = 0 
goal: n < d → (PowerSeries.coeff K n) f = 0

full_name: LaurentSeries.intValuation_le_iff_coeff_lt_eq_zero
code: theorem intValuation_le_iff_coeff_lt_eq_zero {d : ℕ} (f : K⟦X⟧) :
    Valued.v (f : LaurentSeries K) ≤ Multiplicative.ofAdd (-d : ℤ) ↔
      ∀ n : ℕ, n < d → coeff K n f = 0 
goal: Valued.v ((HahnSeries.ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d)) ↔ ∀ n < d, (PowerSeries.coeff K n) f = 0

full_name: LaurentSeries.coeff_zero_of_lt_valuation
code: theorem coeff_zero_of_lt_valuation {n D : ℤ} {f : LaurentSeries K}
    (H : Valued.v f ≤ Multiplicative.ofAdd (-D)) : n < D → f.coeff n = 0 
goal: n < D → f.coeff n = 0

full_name: LaurentSeries.valuation_le_iff_coeff_lt_eq_zero
code: theorem valuation_le_iff_coeff_lt_eq_zero {D : ℤ} {f : LaurentSeries K} :
    Valued.v f ≤ ↑(Multiplicative.ofAdd (-D : ℤ)) ↔ ∀ n : ℤ, n < D → f.coeff n = 0 
goal: Valued.v f ≤ ↑(Multiplicative.ofAdd (-D)) ↔ ∀ n < D, f.coeff n = 0

full_name: LaurentSeries.eq_coeff_of_valuation_sub_lt
code: theorem eq_coeff_of_valuation_sub_lt {d n : ℤ} {f g : LaurentSeries K}
    (H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))) : n < d → g.coeff n = f.coeff n 
goal: n < d → g.coeff n = f.coeff n

full_name: LaurentSeries.val_le_one_iff_eq_coe
code: theorem val_le_one_iff_eq_coe (f : LaurentSeries K) : Valued.v f ≤ (1 : ℤₘ₀) ↔
    ∃ F : PowerSeries K, F = f 
goal: Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f