Laurent Series

In this file we define LaurentSeries R, the formal Laurent series over R, here an arbitrary type with a zero. They are denoted R⸨X⸩.

Main Definitions

• Defines LaurentSeries as an abbreviation for HahnSeries ℤ.
• Defines hasseDeriv of a Laurent series with coefficients in a module over a ring.
• Provides a coercion from power series R⟦X⟧intoR⸨X⸩given byHahnSeries.ofPowerSeries`.
• Defines LaurentSeries.powerSeriesPart
• Defines the localization map LaurentSeries.of_powerSeries_localization which evaluates to HahnSeries.ofPowerSeries.
• Embedding of rational functions into Laurent series, provided as a coercion, utilizing the underlying RatFunc.coeAlgHom.
• Study of the X-Adic valuation on the ring of Laurent series over a field
• In LaurentSeries.uniformContinuous_coeff we show that sending a Laurent series to its dth coefficient is uniformly continuous, ensuring that it sends a Cauchy filter ℱ in K⸨X⸩ to a Cauchy filter in K: since this latter is given the discrete topology, this provides an element LaurentSeries.Cauchy.coeff ℱ d in K that serves as dth coefficient of the Laurent series to which the filter ℱ converges.

Main Results

• Basic properties of Hasse derivatives

About the X-Adic valuation:

• The (integral) valuation of a power series is the order of the first non-zero coefficient, see LaurentSeries.intValuation_le_iff_coeff_lt_eq_zero.
• The valuation of a Laurent series is the order of the first non-zero coefficient, see LaurentSeries.valuation_le_iff_coeff_lt_eq_zero.
• Every Laurent series of valuation less than (1 : ℤₘ₀) comes from a power series, see LaurentSeries.val_le_one_iff_eq_coe.
• The uniform space of LaurentSeries over a field is complete, formalized in the instance instLaurentSeriesComplete.
• The field of rational functions is dense in LaurentSeries: this is the declaration LaurentSeries.coe_range_dense and relies principally upon LaurentSeries.exists_ratFunc_val_lt, stating that for every Laurent series f and every γ : ℤₘ₀ one can find a rational function Q such that the X-adic valuation v satifies v (f - Q) < γ.
• In LaurentSeries.valuation_compare we prove that the extension of the X-adic valuation from RatFunc K up to its abstract completion coincides, modulo the isomorphism with K⸨X⸩, with the X-adic valuation on K⸨X⸩.
• The two declaration LaurentSeries.mem_integers_of_powerSeries and LaurentSeries.exists_powerSeries_of_memIntegers show that an element in the completion of RatFunc K is in the unit ball if and only if it comes from a power series through the isomorphism LaurentSeriesRingEquiv.
• LaurentSeries.powerSeriesRingEquiv is the ring isomorphism between K⟦X⟧ and the unit ball inside the X-adic completion of RatFunc K.

Implementation details

• Since LaurentSeries is just an abbreviation of HahnSeries ℤ _, the definition of the coefficients is given in terms of HahnSeries.coeff and this forces sometimes to go back-and-forth from X : _⸨X⸩ to single 1 1 : HahnSeries ℤ _.
• To prove the isomorphism between the X-adic completion of RatFunc K and K⸨X⸩ we construct two completions of RatFunc K: the first (LaurentSeries.ratfuncAdicComplPkg) is its abstract uniform completion; the second (LaurentSeries.LaurentSeriesPkg) is simply K⸨X⸩, once we prove that it is complete and contains RatFunc K as a dense subspace. The isomorphism is the comparison equivalence, expressing the mathematical idea that the completion "is unique". It is LaurentSeries.comparePkg.
• For applications to K⟦X⟧ it is actually more handy to use the inverse of the above equivalence: LaurentSeries.LaurentSeriesRingEquiv is the topological, ring equivalence K⸨X⸩ ≃+* RatFuncAdicCompl K.
• In order to compare K⟦X⟧ with the valuation subring in the X-adic completion of RatFunc K we consider its alias LaurentSeries.powerSeries_as_subring as a subring of K⸨X⸩, that is itself clearly isomorphic (via LaurentSeries.powerSeriesEquivSubring.symm) to K⟦X⟧.

To Do

• The AdicCompletion construction is currently done for ideals in rings and does not take into account the relation with algebra structures on the ring, hence it does not yield a K-algebra structure on the X-adic completion of K⸨X⸩. Once this will be available, we should update LaurentSeries.LaurentSeriesRingEquiv to an algebra equivalence.

@[reducible, inline]

abbrev LaurentSeries (R : Type u) [Zero R] : Type u

LaurentSeries R is the type of formal Laurent series with coefficients in R, denoted R⸨X⸩.

It is implemented as a HahnSeries with value group ℤ.

Equations

• LaurentSeries R = HahnSeries ℤ R

def LaurentSeries.«term_⸨X⸩» : Lean.TrailingParserDescr

R⸨X⸩ is notation for LaurentSeries R,

Equations

• LaurentSeries.«term_⸨X⸩» = Lean.ParserDescr.trailingNode `LaurentSeries.«term_⸨X⸩» 9000 0 (Lean.ParserDescr.symbol "⸨X⸩")

def LaurentSeries.hasseDeriv (R : Type u_2) {V : Type u_3} [AddCommGroup V] [Semiring R] [Module R V] (k : ℕ) : LaurentSeries V →ₗ[R] LaurentSeries V

The Hasse derivative of Laurent series, as a linear map.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem LaurentSeries.hasseDeriv_coeff {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k : ℕ) (f : LaurentSeries V) (n : ℤ) : ((LaurentSeries.hasseDeriv R k) f).coeff n = Ring.choose (n + ↑k) k • f.coeff (n + ↑k)

@[simp]

theorem LaurentSeries.hasseDeriv_zero {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] : LaurentSeries.hasseDeriv R 0 = LinearMap.id

theorem LaurentSeries.hasseDeriv_single_add {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k : ℕ) (n : ℤ) (x : V) : (LaurentSeries.hasseDeriv R k) ((HahnSeries.single (n + ↑k)) x) = (HahnSeries.single n) (Ring.choose (n + ↑k) k • x)

@[simp]

theorem LaurentSeries.hasseDeriv_single {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k : ℕ) (n : ℤ) (x : V) : (LaurentSeries.hasseDeriv R k) ((HahnSeries.single n) x) = (HahnSeries.single (n - ↑k)) (Ring.choose n k • x)

theorem LaurentSeries.hasseDeriv_comp_coeff {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k l : ℕ) (f : LaurentSeries V) (n : ℤ) : ((LaurentSeries.hasseDeriv R k) ((LaurentSeries.hasseDeriv R l) f)).coeff n = ((k + l).choose k • (LaurentSeries.hasseDeriv R (k + l)) f).coeff n

@[simp]

theorem LaurentSeries.hasseDeriv_comp {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k l : ℕ) (f : LaurentSeries V) : (LaurentSeries.hasseDeriv R k) ((LaurentSeries.hasseDeriv R l) f) = (k + l).choose k • (LaurentSeries.hasseDeriv R (k + l)) f

def LaurentSeries.derivative (R : Type u_3) {V : Type u_4} [AddCommGroup V] [Semiring R] [Module R V] : LaurentSeries V →ₗ[R] LaurentSeries V

The derivative of a Laurent series.

Equations

• LaurentSeries.derivative R = LaurentSeries.hasseDeriv R 1

@[simp]

theorem LaurentSeries.derivative_apply {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (f : LaurentSeries V) : (LaurentSeries.derivative R) f = (LaurentSeries.hasseDeriv R 1) f

theorem LaurentSeries.derivative_iterate {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k : ℕ) (f : LaurentSeries V) : (⇑(LaurentSeries.derivative R))^[k] f = k.factorial • (LaurentSeries.hasseDeriv R k) f

@[simp]

theorem LaurentSeries.derivative_iterate_coeff {R : Type u_1} [Semiring R] {V : Type u_2} [AddCommGroup V] [Module R V] (k : ℕ) (f : LaurentSeries V) (n : ℤ) : ((⇑(LaurentSeries.derivative R))^[k] f).coeff n = (descPochhammer ℤ k).smeval (n + ↑k) • f.coeff (n + ↑k)

instance LaurentSeries.instCoePowerSeries {R : Type u_1} [Semiring R] : Coe (PowerSeries R) (LaurentSeries R)

Equations

• LaurentSeries.instCoePowerSeries = { coe := ⇑(HahnSeries.ofPowerSeries ℤ R) }

@[simp]

theorem LaurentSeries.coeff_coe_powerSeries {R : Type u_1} [Semiring R] (x : PowerSeries R) (n : ℕ) : ((HahnSeries.ofPowerSeries ℤ R) x).coeff ↑n = (PowerSeries.coeff R n) x

def LaurentSeries.powerSeriesPart {R : Type u_1} [Semiring R] (x : LaurentSeries R) : PowerSeries R

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.

Equations

• x.powerSeriesPart = PowerSeries.mk fun (n : ℕ) => x.coeff (HahnSeries.order x + ↑n)

@[simp]

theorem LaurentSeries.powerSeriesPart_coeff {R : Type u_1} [Semiring R] (x : LaurentSeries R) (n : ℕ) : (PowerSeries.coeff R n) x.powerSeriesPart = x.coeff (HahnSeries.order x + ↑n)

@[simp]

theorem LaurentSeries.powerSeriesPart_zero {R : Type u_1} [Semiring R] : LaurentSeries.powerSeriesPart 0 = 0

@[simp]

theorem LaurentSeries.powerSeriesPart_eq_zero {R : Type u_1} [Semiring R] (x : LaurentSeries R) : x.powerSeriesPart = 0 ↔ x = 0

@[simp]

theorem LaurentSeries.single_order_mul_powerSeriesPart {R : Type u_1} [Semiring R] (x : LaurentSeries R) : (HahnSeries.single (HahnSeries.order x)) 1 * (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = x

theorem LaurentSeries.ofPowerSeries_powerSeriesPart {R : Type u_1} [Semiring R] (x : LaurentSeries R) : (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = (HahnSeries.single (-HahnSeries.order x)) 1 * x

theorem LaurentSeries.X_order_mul_powerSeriesPart {R : Type u_1} [Semiring R] {n : ℕ} {f : LaurentSeries R} (hn : ↑n = HahnSeries.order f) : (HahnSeries.ofPowerSeries ℤ R) (PowerSeries.X ^ n * f.powerSeriesPart) = f

instance LaurentSeries.instAlgebraPowerSeries {R : Type u_1} [CommSemiring R] : Algebra (PowerSeries R) (LaurentSeries R)

Equations

• LaurentSeries.instAlgebraPowerSeries = (HahnSeries.ofPowerSeries ℤ R).toAlgebra

@[simp]

theorem LaurentSeries.coe_algebraMap {R : Type u_1} [CommSemiring R] : ⇑(algebraMap (PowerSeries R) (LaurentSeries R)) = ⇑(HahnSeries.ofPowerSeries ℤ R)

instance LaurentSeries.of_powerSeries_localization {R : Type u_1} [CommRing R] : IsLocalization (Submonoid.powers PowerSeries.X) (LaurentSeries R)

The localization map from power series to Laurent series.

Equations

• ⋯ = ⋯

instance LaurentSeries.instIsFractionRingPowerSeries {K : Type u_2} [Field K] : IsFractionRing (PowerSeries K) (LaurentSeries K)

Equations

• ⋯ = ⋯

theorem PowerSeries.coe_zero {R : Type u_1} [Semiring R] : (HahnSeries.ofPowerSeries ℤ R) 0 = 0

theorem PowerSeries.coe_one {R : Type u_1} [Semiring R] : (HahnSeries.ofPowerSeries ℤ R) 1 = 1

theorem PowerSeries.coe_add {R : Type u_1} [Semiring R] (f g : PowerSeries R) : (HahnSeries.ofPowerSeries ℤ R) (f + g) = (HahnSeries.ofPowerSeries ℤ R) f + (HahnSeries.ofPowerSeries ℤ R) g

theorem PowerSeries.coe_sub {R' : Type u_2} [Ring R'] (f' g' : PowerSeries R') : (HahnSeries.ofPowerSeries ℤ R') (f' - g') = (HahnSeries.ofPowerSeries ℤ R') f' - (HahnSeries.ofPowerSeries ℤ R') g'

theorem PowerSeries.coe_neg {R' : Type u_2} [Ring R'] (f' : PowerSeries R') : (HahnSeries.ofPowerSeries ℤ R') (-f') = -(HahnSeries.ofPowerSeries ℤ R') f'

theorem PowerSeries.coe_mul {R : Type u_1} [Semiring R] (f g : PowerSeries R) : (HahnSeries.ofPowerSeries ℤ R) (f * g) = (HahnSeries.ofPowerSeries ℤ R) f * (HahnSeries.ofPowerSeries ℤ R) g

theorem PowerSeries.coeff_coe {R : Type u_1} [Semiring R] (f : PowerSeries R) (i : ℤ) : ((HahnSeries.ofPowerSeries ℤ R) f).coeff i = if i < 0 then 0 else (PowerSeries.coeff R i.natAbs) f

theorem PowerSeries.coe_C {R : Type u_1} [Semiring R] (r : R) : (HahnSeries.ofPowerSeries ℤ R) ((PowerSeries.C R) r) = HahnSeries.C r

theorem PowerSeries.coe_X {R : Type u_1} [Semiring R] : (HahnSeries.ofPowerSeries ℤ R) PowerSeries.X = (HahnSeries.single 1) 1

@[simp]

theorem PowerSeries.coe_smul {R : Type u_1} [Semiring R] {S : Type u_3} [Semiring S] [Module R S] (r : R) (x : PowerSeries S) : (HahnSeries.ofPowerSeries ℤ S) (r • x) = r • (HahnSeries.ofPowerSeries ℤ S) x

theorem PowerSeries.coe_pow {R : Type u_1} [Semiring R] (f : PowerSeries R) (n : ℕ) : (HahnSeries.ofPowerSeries ℤ R) (f ^ n) = (HahnSeries.ofPowerSeries ℤ R) f ^ n

def RatFunc.coeAlgHom (F : Type u) [Field F] : RatFunc F →ₐ[Polynomial F] LaurentSeries F

The coercion RatFunc F → F⸨X⸩ as bundled alg hom.

Equations

• RatFunc.coeAlgHom F = RatFunc.liftAlgHom (Algebra.ofId (Polynomial F) (LaurentSeries F)) ⋯

def RatFunc.coeToLaurentSeries_fun {F : Type u} [Field F] : RatFunc F → LaurentSeries F

The coercion RatFunc F → F⸨X⸩ as a function.

This is the implementation of coeToLaurentSeries.

Equations

• RatFunc.coeToLaurentSeries_fun = ⇑(RatFunc.coeAlgHom F)

instance RatFunc.coeToLaurentSeries {F : Type u} [Field F] : Coe (RatFunc F) (LaurentSeries F)

Equations

• RatFunc.coeToLaurentSeries = { coe := RatFunc.coeToLaurentSeries_fun }

theorem RatFunc.coe_def {F : Type u} [Field F] (f : RatFunc F) : ↑f = (RatFunc.coeAlgHom F) f

theorem RatFunc.coe_num_denom {F : Type u} [Field F] (f : RatFunc F) : ↑f = (HahnSeries.ofPowerSeries ℤ F) ↑f.num / (HahnSeries.ofPowerSeries ℤ F) ↑f.denom

theorem RatFunc.coe_injective {F : Type u} [Field F] : Function.Injective RatFunc.coeToLaurentSeries_fun

@[simp]

theorem RatFunc.coe_apply {F : Type u} [Field F] (f : RatFunc F) : (RatFunc.coeAlgHom F) f = ↑f

theorem RatFunc.coe_coe {F : Type u} [Field F] (P : Polynomial F) : (HahnSeries.ofPowerSeries ℤ F) ↑P = ↑↑P

@[simp]

theorem RatFunc.coe_zero {F : Type u} [Field F] : ↑0 = 0

theorem RatFunc.coe_ne_zero {F : Type u} [Field F] {f : Polynomial F} (hf : f ≠ 0) : ↑f ≠ 0

@[simp]

theorem RatFunc.coe_one {F : Type u} [Field F] : ↑1 = 1

@[simp]

theorem RatFunc.coe_add {F : Type u} [Field F] (f g : RatFunc F) : ↑(f + g) = ↑f + ↑g

@[simp]

theorem RatFunc.coe_sub {F : Type u} [Field F] (f g : RatFunc F) : ↑(f - g) = ↑f - ↑g

@[simp]

theorem RatFunc.coe_neg {F : Type u} [Field F] (f : RatFunc F) : ↑(-f) = -↑f

@[simp]

theorem RatFunc.coe_mul {F : Type u} [Field F] (f g : RatFunc F) : ↑(f * g) = ↑f * ↑g

@[simp]

theorem RatFunc.coe_pow {F : Type u} [Field F] (f : RatFunc F) (n : ℕ) : ↑(f ^ n) = ↑f ^ n

@[simp]

theorem RatFunc.coe_div {F : Type u} [Field F] (f g : RatFunc F) : ↑(f / g) = ↑f / ↑g

@[simp]

theorem RatFunc.coe_C {F : Type u} [Field F] (r : F) : ↑(RatFunc.C r) = HahnSeries.C r

@[simp]

theorem RatFunc.coe_smul {F : Type u} [Field F] (f : RatFunc F) (r : F) : ↑(r • f) = r • ↑f

@[simp]

theorem RatFunc.coe_X {F : Type u} [Field F] : ↑RatFunc.X = (HahnSeries.single 1) 1

theorem RatFunc.single_one_eq_pow {R : Type u_2} [Ring R] (n : ℕ) : (HahnSeries.single ↑n) 1 = (HahnSeries.single 1) 1 ^ n

theorem RatFunc.single_inv {F : Type u} [Field F] (d : ℤ) {α : F} (hα : α ≠ 0) : (HahnSeries.single (-d)) α⁻¹ = ((HahnSeries.single d) α)⁻¹

theorem RatFunc.single_zpow {F : Type u} [Field F] (n : ℤ) : (HahnSeries.single n) 1 = (HahnSeries.single 1) 1 ^ n

instance RatFunc.instAlgebraLaurentSeries {F : Type u} [Field F] : Algebra (RatFunc F) (LaurentSeries F)

Equations

• RatFunc.instAlgebraLaurentSeries = (RatFunc.coeAlgHom F).toAlgebra

theorem RatFunc.algebraMap_apply_div {F : Type u} [Field F] (p q : Polynomial F) : (algebraMap (RatFunc F) (LaurentSeries F)) ((algebraMap (Polynomial F) (RatFunc F)) p / (algebraMap (Polynomial F) (RatFunc F)) q) = (algebraMap (Polynomial F) (LaurentSeries F)) p / (algebraMap (Polynomial F) (LaurentSeries F)) q

instance RatFunc.instIsScalarTowerPolynomialLaurentSeries {F : Type u} [Field F] : IsScalarTower (Polynomial F) (RatFunc F) (LaurentSeries F)

Equations

• ⋯ = ⋯

def PowerSeries.idealX (K : Type u_2) [Field K] : IsDedekindDomain.HeightOneSpectrum (PowerSeries K)

The prime ideal (X) of K⟦X⟧, when K is a field, as a term of the HeightOneSpectrum.

Equations

• PowerSeries.idealX K = { asIdeal := Ideal.span {PowerSeries.X}, isPrime := ⋯, ne_bot := ⋯ }

theorem PowerSeries.intValuation_eq_of_coe {K : Type u_2} [Field K] (P : Polynomial K) : (Polynomial.idealX K).intValuation P = (PowerSeries.idealX K).intValuation ↑P

@[simp]

theorem PowerSeries.intValuation_X {K : Type u_2} [Field K] : (PowerSeries.idealX K).intValuationDef PowerSeries.X = ↑(Multiplicative.ofAdd (-1))

The integral valuation of the power series X : K⟦X⟧ equals (ofAdd -1) : ℤₘ₀

theorem RatFunc.valuation_eq_LaurentSeries_valuation (K : Type u_2) [Field K] (P : RatFunc K) : (Polynomial.idealX K).valuation P = (PowerSeries.idealX K).valuation ↑P

instance LaurentSeries.instValuedWithZeroMultiplicativeInt (K : Type u_2) [Field K] : Valued (LaurentSeries K) (WithZero (Multiplicative ℤ))

Equations

• LaurentSeries.instValuedWithZeroMultiplicativeInt K = Valued.mk' (PowerSeries.idealX K).valuation

theorem LaurentSeries.valuation_X_pow (K : Type u_2) [Field K] (s : ℕ) : Valued.v ((HahnSeries.ofPowerSeries ℤ K) PowerSeries.X ^ s) = ↑(Multiplicative.ofAdd (-↑s))

theorem LaurentSeries.valuation_single_zpow (K : Type u_2) [Field K] (s : ℤ) : Valued.v ((HahnSeries.single s) 1) = ↑(Multiplicative.ofAdd (-s))

theorem LaurentSeries.coeff_zero_of_lt_intValuation (K : Type u_2) [Field K] {n d : ℕ} {f : PowerSeries K} (H : Valued.v ((HahnSeries.ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))) : n < d → (PowerSeries.coeff K n) f = 0

theorem LaurentSeries.intValuation_le_iff_coeff_lt_eq_zero (K : Type u_2) [Field K] {d : ℕ} (f : PowerSeries K) : Valued.v ((HahnSeries.ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d)) ↔ ∀ n < d, (PowerSeries.coeff K n) f = 0

theorem LaurentSeries.coeff_zero_of_lt_valuation (K : Type u_2) [Field K] {n D : ℤ} {f : LaurentSeries K} (H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))) : n < D → f.coeff n = 0

theorem LaurentSeries.valuation_le_iff_coeff_lt_eq_zero (K : Type u_2) [Field K] {D : ℤ} {f : LaurentSeries K} : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D)) ↔ ∀ n < D, f.coeff n = 0

theorem LaurentSeries.eq_coeff_of_valuation_sub_lt (K : Type u_2) [Field K] {d n : ℤ} {f g : LaurentSeries K} (H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))) : n < d → g.coeff n = f.coeff n

theorem LaurentSeries.val_le_one_iff_eq_coe (K : Type u_2) [Field K] (f : LaurentSeries K) : Valued.v f ≤ 1 ↔ ∃ (F : PowerSeries K), (HahnSeries.ofPowerSeries ℤ K) F = f

theorem LaurentSeries.uniformContinuous_coeff {K : Type u_2} [Field K] {uK : UniformSpace K} (d : ℤ) : UniformContinuous fun (f : LaurentSeries K) => f.coeff d

def LaurentSeries.Cauchy.coeff {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : ℤ → K

Since extracting coefficients is uniformly continuous, every Cauchy filter in K⸨X⸩ gives rise to a Cauchy filter in K for every d : ℤ, and such Cauchy filter in K converges to a principal filter

Equations

• LaurentSeries.Cauchy.coeff hℱ = fun (d : ℤ) => UniformSpace.DiscreteUnif.cauchyConst ⋯ ⋯

theorem LaurentSeries.Cauchy.coeff_tendsto {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) (D : ℤ) : Filter.Tendsto (fun (f : LaurentSeries K) => f.coeff D) ℱ (Filter.principal {LaurentSeries.Cauchy.coeff hℱ D})

theorem LaurentSeries.Cauchy.exists_lb_eventual_support {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : ∃ (N : ℤ), ∀ᶠ (f : LaurentSeries K) in ℱ, ∀ n < N, f.coeff n = 0

theorem LaurentSeries.Cauchy.exists_lb_support {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : ∃ (N : ℤ), ∀ n < N, LaurentSeries.Cauchy.coeff hℱ n = 0

theorem LaurentSeries.Cauchy.coeff_support_bddBelow {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : BddBelow (Function.support (LaurentSeries.Cauchy.coeff hℱ))

def LaurentSeries.Cauchy.limit {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : LaurentSeries K

To any Cauchy filter ℱ of K⸨X⸩, we can attach a laurent series that is the limit of the filter. Its d-th coefficient is defined as the limit of Cauchy.coeff hℱ d, which is again Cauchy but valued in the discrete space K. That sufficiently negative coefficients vanish follows from Cauchy.coeff_support_bddBelow

Equations

• LaurentSeries.Cauchy.limit hℱ = { coeff := LaurentSeries.Cauchy.coeff hℱ, isPWO_support' := ⋯ }

theorem LaurentSeries.Cauchy.exists_lb_coeff_ne {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) : ∃ (N : ℤ), ∀ᶠ (f : LaurentSeries K) in ℱ, ∀ d < N, LaurentSeries.Cauchy.coeff hℱ d = f.coeff d

theorem LaurentSeries.Cauchy.coeff_eventually_equal {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) {D : ℤ} : ∀ᶠ (f : LaurentSeries K) in ℱ, ∀ d < D, LaurentSeries.Cauchy.coeff hℱ d = f.coeff d

theorem LaurentSeries.Cauchy.eventually_mem_nhds {K : Type u_2} [Field K] {ℱ : Filter (LaurentSeries K)} (hℱ : Cauchy ℱ) {U : Set (LaurentSeries K)} (hU : U ∈ nhds (LaurentSeries.Cauchy.limit hℱ)) : ∀ᶠ (f : LaurentSeries K) in ℱ, f ∈ U

instance LaurentSeries.instLaurentSeriesComplete {K : Type u_2} [Field K] : CompleteSpace (LaurentSeries K)

Equations

• ⋯ = ⋯

theorem LaurentSeries.exists_Polynomial_intValuation_lt {K : Type u_2} [Field K] (F : PowerSeries K) (η : (WithZero (Multiplicative ℤ))ˣ) : ∃ (P : Polynomial K), (PowerSeries.idealX K).intValuation (F - ↑P) < ↑η

theorem LaurentSeries.exists_ratFunc_val_lt {K : Type u_2} [Field K] (f : LaurentSeries K) (γ : (WithZero (Multiplicative ℤ))ˣ) : ∃ (Q : RatFunc K), Valued.v (f - ↑Q) < ↑γ

For every Laurent series f and every γ : ℤₘ₀ one can find a rational function Q such that the X-adic valuation v satifies v (f - Q) < γ.

theorem LaurentSeries.coe_range_dense {K : Type u_2} [Field K] : DenseRange RatFunc.coeToLaurentSeries_fun

theorem LaurentSeries.inducing_coe {K : Type u_2} [Field K] : IsUniformInducing RatFunc.coeToLaurentSeries_fun

theorem LaurentSeries.continuous_coe {K : Type u_2} [Field K] : Continuous RatFunc.coeToLaurentSeries_fun

@[reducible, inline]

abbrev LaurentSeries.ratfuncAdicComplPkg {K : Type u_2} [Field K] : AbstractCompletion (RatFunc K)

The X-adic completion as an abstract completion of RatFunc K

Equations

• LaurentSeries.ratfuncAdicComplPkg = UniformSpace.Completion.cPkg

noncomputable def LaurentSeries.LaurentSeriesPkg (K : Type u_2) [Field K] : AbstractCompletion (RatFunc K)

Having established that the K⸨X⸩ is complete and contains RatFunc K as a dense subspace, it gives rise to an abstract completion of RatFunc K.

Equations

• One or more equations did not get rendered due to their size.

instance LaurentSeries.instTopologicalSpaceSpaceRatFuncLaurentSeriesPkg (K : Type u_2) [Field K] : TopologicalSpace (LaurentSeries.LaurentSeriesPkg K).space

Equations

• LaurentSeries.instTopologicalSpaceSpaceRatFuncLaurentSeriesPkg K = UniformSpace.toTopologicalSpace

@[simp]

theorem LaurentSeries.LaurentSeries_coe (K : Type u_2) [Field K] (x : RatFunc K) : (LaurentSeries.LaurentSeriesPkg K).coe x = ↑x

@[reducible, inline]

abbrev LaurentSeries.extensionAsRingHom (K : Type u_2) [Field K] (hf : Continuous ⇑(RatFunc.coeAlgHom K).toRingHom) [CompleteSpace (LaurentSeries K)] [T0Space (LaurentSeries K)] : UniformSpace.Completion (RatFunc K) →+* LaurentSeries K

Reintrerpret the extension of coe : RatFunc K → K⸨X⸩ as ring homomorphism

Equations

• LaurentSeries.extensionAsRingHom K = UniformSpace.Completion.extensionHom (RatFunc.coeAlgHom K).toRingHom

@[reducible, inline]

abbrev LaurentSeries.RatFuncAdicCompl (K : Type u_2) [Field K] : Type u_2

An abbreviation for the X-adic completion of RatFunc K

Equations

• LaurentSeries.RatFuncAdicCompl K = IsDedekindDomain.HeightOneSpectrum.adicCompletion (RatFunc K) (Polynomial.idealX K)

instance LaurentSeries.instUniformSpaceRatFuncAdicCompl (K : Type u_2) [Field K] : UniformSpace (LaurentSeries.RatFuncAdicCompl K)

Equations

• LaurentSeries.instUniformSpaceRatFuncAdicCompl K = inferInstance

instance LaurentSeries.instUniformSpace (K : Type u_2) [Field K] : UniformSpace (LaurentSeries K)

Equations

• LaurentSeries.instUniformSpace K = inferInstance

@[reducible, inline]

abbrev LaurentSeries.comparePkg (K : Type u_2) [Field K] : LaurentSeries.RatFuncAdicCompl K ≃ᵤ LaurentSeries K

The uniform space isomorphism between two abstract completions of ratfunc K

Equations

• LaurentSeries.comparePkg K = LaurentSeries.ratfuncAdicComplPkg.compareEquiv (LaurentSeries.LaurentSeriesPkg K)

theorem LaurentSeries.comparePkg_eq_extension (K : Type u_2) [Field K] (x : UniformSpace.Completion (RatFunc K)) : (LaurentSeries.comparePkg K).toFun x = (↑↑(LaurentSeries.extensionAsRingHom K ⋯)).toFun x

@[reducible, inline]

abbrev LaurentSeries.ratfuncAdicComplRingEquiv (K : Type u_2) [Field K] : LaurentSeries.RatFuncAdicCompl K ≃+* LaurentSeries K

The uniform space equivalence between two abstract completions of ratfunc K as a ring equivalence: this will be the inverse of the fundamental one.

Equations

• LaurentSeries.ratfuncAdicComplRingEquiv K = { toEquiv := (LaurentSeries.comparePkg K).toEquiv, map_mul' := ⋯, map_add' := ⋯ }

@[reducible, inline]

abbrev LaurentSeries.LaurentSeriesRingEquiv (K : Type u_2) [Field K] : LaurentSeries K ≃+* LaurentSeries.RatFuncAdicCompl K

The uniform space equivalence between two abstract completions of ratfunc K as a ring equivalence: it goes from K⸨X⸩ to RatFuncAdicCompl K

Equations

• LaurentSeries.LaurentSeriesRingEquiv K = (LaurentSeries.ratfuncAdicComplRingEquiv K).symm

@[simp]

theorem LaurentSeries.ratfuncAdicComplRingEquiv_apply (K : Type u_2) [Field K] (x : LaurentSeries.RatFuncAdicCompl K) : (LaurentSeries.ratfuncAdicComplRingEquiv K) x = LaurentSeries.ratfuncAdicComplPkg.compare (LaurentSeries.LaurentSeriesPkg K) x

theorem LaurentSeries.coe_X_compare (K : Type u_2) [Field K] : (LaurentSeries.ratfuncAdicComplRingEquiv K) (↑(RatFunc K) RatFunc.X) = (HahnSeries.ofPowerSeries ℤ K) PowerSeries.X

theorem LaurentSeries.valuation_LaurentSeries_equal_extension (K : Type u_2) [Field K] : ⋯.extend ⇑Valued.v = ⇑Valued.v

theorem LaurentSeries.tendsto_valuation (K : Type u_2) [Field K] (a : IsDedekindDomain.HeightOneSpectrum.adicCompletion (RatFunc K) (Polynomial.idealX K)) : Filter.Tendsto (⇑Valued.v) (Filter.comap (↑(RatFunc K)) (nhds a)) (nhds (Valued.v a))

theorem LaurentSeries.valuation_compare (K : Type u_2) [Field K] (f : LaurentSeries K) : Valued.v ((LaurentSeries.LaurentSeriesPkg K).compare LaurentSeries.ratfuncAdicComplPkg f) = Valued.v f

@[reducible, inline]

abbrev LaurentSeries.powerSeries_as_subring (K : Type u_2) [Field K] : Subring (LaurentSeries K)

In order to compare K⟦X⟧ with the valuation subring in the X-adic completion of RatFunc K we consider its alias as a subring of K⸨X⸩.

Equations

• LaurentSeries.powerSeries_as_subring K = (HahnSeries.ofPowerSeries ℤ K).range

@[reducible, inline]

abbrev LaurentSeries.powerSeriesEquivSubring (K : Type u_2) [Field K] : PowerSeries K ≃+* ↥(LaurentSeries.powerSeries_as_subring K)

The ring K⟦X⟧ is isomorphic to the subring powerSeries_as_subring K

Equations

• LaurentSeries.powerSeriesEquivSubring K = ⋯.mpr (⋯.mpr (Subring.topEquiv.symm.trans (⊤.equivMapOfInjective (HahnSeries.ofPowerSeries ℤ K) ⋯)))

theorem LaurentSeries.mem_integers_of_powerSeries (K : Type u_2) [Field K] (F : PowerSeries K) : (LaurentSeries.LaurentSeriesRingEquiv K) ((HahnSeries.ofPowerSeries ℤ K) F) ∈ IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers (RatFunc K) (Polynomial.idealX K)

theorem LaurentSeries.exists_powerSeries_of_memIntegers (K : Type u_2) [Field K] {x : LaurentSeries.RatFuncAdicCompl K} (hx : x ∈ IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers (RatFunc K) (Polynomial.idealX K)) : ∃ (F : PowerSeries K), (LaurentSeries.LaurentSeriesRingEquiv K) ((HahnSeries.ofPowerSeries ℤ K) F) = x

theorem LaurentSeries.powerSeries_ext_subring (K : Type u_2) [Field K] : Subring.map (LaurentSeries.LaurentSeriesRingEquiv K).toRingHom (LaurentSeries.powerSeries_as_subring K) = (IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers (RatFunc K) (Polynomial.idealX K)).toSubring

@[reducible, inline]

abbrev LaurentSeries.powerSeriesRingEquiv (K : Type u_2) [Field K] : PowerSeries K ≃+* ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers (RatFunc K) (Polynomial.idealX K))

The ring isomorphism between K⟦X⟧ and the unit ball inside the X-adic completion of RatFunc K.

Equations

• LaurentSeries.powerSeriesRingEquiv K = ((LaurentSeries.powerSeriesEquivSubring K).trans (LaurentSeries.LaurentSeriesRingEquiv K).subringMap).trans (RingEquiv.subringCongr ⋯)