Documentation

Mathlib.RingTheory.HahnSeries.Multiplication

Multiplicative properties of Hahn series #

If Γ is ordered and R has zero, then HahnSeries Γ R consists of formal series over Γ with coefficients in R, whose supports are partially well-ordered. With further structure on R and Γ, we can add further structure on HahnSeries Γ R. We prove some facts about multiplying Hahn series.

Main Definitions #

HahnModule is a type alias for HahnSeries, which we use for defining scalar multiplication of HahnSeries Γ R on HahnModule Γ' R V for an R-module V, where Γ' admits an ordered cancellative vector addition operation from Γ.

Main results #

If R is a (commutative) (semi-)ring, then so is HahnSeries Γ R.
If V is an R-module, then HahnModule Γ' R V is a HahnSeries Γ R-module.

TODO #

Scalar tower instances

References #

[J. van der Hoeven, Operators on Generalized Power Series][van_der_hoeven]

instance HahnSeries.instOne {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [Zero R] [One R] :

One (HahnSeries Γ R)

Equations

HahnSeries.instOne = { one := (HahnSeries.single 0) 1 }

@[simp]

theorem HahnSeries.one_coeff {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [Zero R] [One R] {a : Γ} :

HahnSeries.coeff 1 a = if a = 0 then 1 else 0

@[simp]

theorem HahnSeries.single_zero_one {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [Zero R] [One R] :

(HahnSeries.single 0) 1 = 1

@[simp]

theorem HahnSeries.support_one {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [MulZeroOneClass R] [Nontrivial R] :

HahnSeries.support 1 = {0}

@[simp]

theorem HahnSeries.orderTop_one {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [MulZeroOneClass R] [Nontrivial R] :

HahnSeries.orderTop 1 = 0

@[simp]

theorem HahnSeries.order_one {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [MulZeroOneClass R] :

HahnSeries.order 1 = 0

@[simp]

theorem HahnSeries.leadingCoeff_one {Γ : Type u_1} {R : Type u_3} [Zero Γ] [PartialOrder Γ] [MulZeroOneClass R] :

HahnSeries.leadingCoeff 1 = 1

def HahnModule (Γ : Type u_5) (R : Type u_6) (V : Type u_7) [PartialOrder Γ] [Zero V] [SMul R V] :

Type (max u_5 u_7)

We introduce a type alias for HahnSeries in order to work with scalar multiplication by series. If we wrote a SMul (HahnSeries Γ R) (HahnSeries Γ V) instance, then when V = HahnSeries Γ R, we would have two different actions of HahnSeries Γ R on HahnSeries Γ V. See Mathlib.Algebra.Polynomial.Module for more discussion on this problem.

Equations

HahnModule Γ R V = HahnSeries Γ V

Instances For

def HahnModule.of {Γ : Type u_1} {V : Type u_4} [PartialOrder Γ] [Zero V] (R : Type u_5) [SMul R V] :

HahnSeries Γ V ≃ HahnModule Γ R V

The casting function to the type synonym.

Equations

HahnModule.of R = Equiv.refl (HahnSeries Γ V)

Instances For

def HahnModule.rec {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [Zero V] [SMul R V] {motive : HahnModule Γ R V → Sort u_5} (h : (x : HahnSeries Γ V) → motive ((HahnModule.of R) x)) (x : HahnModule Γ R V) :

motive x

Recursion principle to reduce a result about the synonym to the original type.

Equations

HahnModule.rec h x = h ((HahnModule.of R).symm x)

Instances For

theorem HahnModule.ext {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [Zero V] [SMul R V] (x : HahnModule Γ R V) (y : HahnModule Γ R V) (h : ((HahnModule.of R).symm x).coeff = ((HahnModule.of R).symm y).coeff) :

x = y

theorem HahnModule.ext_iff {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [Zero V] [SMul R V] (x : HahnModule Γ R V) (y : HahnModule Γ R V) :

((HahnModule.of R).symm x).coeff = ((HahnModule.of R).symm y).coeff ↔ x = y

instance HahnModule.instAddCommMonoid {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] :

AddCommMonoid (HahnModule Γ R V)

Equations

HahnModule.instAddCommMonoid = inferInstanceAs (AddCommMonoid (HahnSeries Γ V))

instance HahnModule.instBaseSMul {Γ : Type u_1} {R : Type u_3} [PartialOrder Γ] {V : Type u_5} [Monoid R] [AddMonoid V] [DistribMulAction R V] :

SMul R (HahnModule Γ R V)

Equations

HahnModule.instBaseSMul = inferInstanceAs (SMul R (HahnSeries Γ V))

@[simp]

theorem HahnModule.of_zero {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] :

(HahnModule.of R) 0 = 0

@[simp]

theorem HahnModule.of_add {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] (x : HahnSeries Γ V) (y : HahnSeries Γ V) :

(HahnModule.of R) (x + y) = (HahnModule.of R) x + (HahnModule.of R) y

@[simp]

theorem HahnModule.of_symm_zero {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] :

(HahnModule.of R).symm 0 = 0

@[simp]

theorem HahnModule.of_symm_add {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] (x : HahnModule Γ R V) (y : HahnModule Γ R V) :

(HahnModule.of R).symm (x + y) = (HahnModule.of R).symm x + (HahnModule.of R).symm y

instance HahnModule.instSMul {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [Zero R] :

SMul (HahnSeries Γ R) (HahnModule Γ' R V)

Equations

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

theorem HahnModule.smul_coeff {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMul R V] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [Zero R] (x : HahnSeries Γ R) (y : HahnModule Γ' R V) (a : Γ') :

((HahnModule.of R).symm (x • y)).coeff a = ∑ ij ∈ Finset.VAddAntidiagonal ⋯ ⋯ a, x.coeff ij.1 • ((HahnModule.of R).symm y).coeff ij.2

instance HahnModule.instBaseSMulZeroClass {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMulZeroClass R V] :

SMulZeroClass R (HahnModule Γ R V)

Equations

HahnModule.instBaseSMulZeroClass = inferInstanceAs (SMulZeroClass R (HahnSeries Γ V))

@[simp]

theorem HahnModule.of_smul {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [AddCommMonoid V] [SMulZeroClass R V] (r : R) (x : HahnSeries Γ V) :

(HahnModule.of R) (r • x) = r • (HahnModule.of R) x

@[simp]

theorem HahnModule.of_symm_smul {Γ : Type u_1} {R : Type u_3} {V : Type u_4} [AddCommMonoid V] [PartialOrder Γ] [SMulZeroClass R V] (r : R) (x : HahnModule Γ R V) :

(HahnModule.of R).symm (r • x) = r • (HahnModule.of R).symm x

instance HahnModule.instSMulZeroClass {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [Zero R] [AddCommMonoid V] [SMulZeroClass R V] :

SMulZeroClass (HahnSeries Γ R) (HahnModule Γ' R V)

Equations

HahnModule.instSMulZeroClass = SMulZeroClass.mk ⋯

theorem HahnModule.smul_coeff_right {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [Zero R] [AddCommMonoid V] [SMulZeroClass R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} {a : Γ'} {s : Set Γ'} (hs : s.IsPWO) (hys : ((HahnModule.of R).symm y).support ⊆ s) :

((HahnModule.of R).symm (x • y)).coeff a = ∑ ij ∈ Finset.VAddAntidiagonal ⋯ hs a, x.coeff ij.1 • ((HahnModule.of R).symm y).coeff ij.2

theorem HahnModule.smul_coeff_left {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [Zero R] [AddCommMonoid V] [SMulWithZero R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} {a : Γ'} {s : Set Γ} (hs : s.IsPWO) (hxs : x.support ⊆ s) :

((HahnModule.of R).symm (x • y)).coeff a = ∑ ij ∈ Finset.VAddAntidiagonal hs ⋯ a, x.coeff ij.1 • ((HahnModule.of R).symm y).coeff ij.2

theorem HahnModule.smul_add {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [Zero R] [DistribSMul R V] (x : HahnSeries Γ R) (y : HahnModule Γ' R V) (z : HahnModule Γ' R V) :

x • (y + z) = x • y + x • z

instance HahnModule.instDistribSMul {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [MonoidWithZero R] [DistribSMul R V] :

DistribSMul (HahnSeries Γ R) (HahnModule Γ' R V)

Equations

HahnModule.instDistribSMul = DistribSMul.mk ⋯

theorem HahnModule.add_smul {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [AddCommMonoid R] [SMulWithZero R V] {x : HahnSeries Γ R} {y : HahnSeries Γ R} {z : HahnModule Γ' R V} (h : ∀ (r s : R) (u : V), (r + s) • u = r • u + s • u) :

(x + y) • z = x • z + y • z

theorem HahnModule.single_smul_coeff_add {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [MulZeroClass R] [SMulWithZero R V] {r : R} {x : HahnModule Γ' R V} {a : Γ'} {b : Γ} :

((HahnModule.of R).symm ((HahnSeries.single b) r • x)).coeff (b +ᵥ a) = r • ((HahnModule.of R).symm x).coeff a

theorem HahnModule.single_zero_smul_coeff {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ'] [AddCommMonoid V] {Γ : Type u_5} [OrderedAddCommMonoid Γ] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R} {x : HahnModule Γ' R V} {a : Γ'} :

((HahnModule.of R).symm ((HahnSeries.single 0) r • x)).coeff a = r • ((HahnModule.of R).symm x).coeff a

@[simp]

theorem HahnModule.single_zero_smul_eq_smul {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ'] [AddCommMonoid V] (Γ : Type u_5) [OrderedAddCommMonoid Γ] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R} {x : HahnModule Γ' R V} :

(HahnSeries.single 0) r • x = r • x

@[simp]

theorem HahnModule.zero_smul' {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [Zero R] [SMulWithZero R V] {x : HahnModule Γ' R V} :

0 • x = 0

@[simp]

theorem HahnModule.one_smul' {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ'] [AddCommMonoid V] {Γ : Type u_5} [OrderedAddCommMonoid Γ] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [MonoidWithZero R] [MulActionWithZero R V] {x : HahnModule Γ' R V} :

1 • x = x

theorem HahnModule.support_smul_subset_vadd_support' {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} :

((HahnModule.of R).symm (x • y)).support ⊆ x.support +ᵥ ((HahnModule.of R).symm y).support

theorem HahnModule.support_smul_subset_vadd_support {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ] [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} :

((HahnModule.of R).symm (x • y)).support ⊆ x.support +ᵥ ((HahnModule.of R).symm y).support

theorem HahnModule.smul_coeff_order_add_order {R : Type u_3} {V : Type u_4} [AddCommMonoid V] {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [Zero R] [SMulWithZero R V] (x : HahnSeries Γ R) (y : HahnModule Γ R V) :

((HahnModule.of R).symm (x • y)).coeff (x.order + ((HahnModule.of R).symm y).order) = x.leadingCoeff • ((HahnModule.of R).symm y).leadingCoeff

instance HahnSeries.instMul {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] :

Mul (HahnSeries Γ R)

Equations

HahnSeries.instMul = { mul := fun (x y : HahnSeries Γ R) => (HahnModule.of R).symm (x • (HahnModule.of R) y) }

theorem HahnSeries.of_symm_smul_of_eq_mul {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} :

(HahnModule.of R).symm (x • (HahnModule.of R) y) = x * y

theorem HahnSeries.mul_coeff {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} {a : Γ} :

(x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal ⋯ ⋯ a, x.coeff ij.1 * y.coeff ij.2

theorem HahnSeries.mul_coeff_left' {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} {a : Γ} {s : Set Γ} (hs : s.IsPWO) (hxs : x.support ⊆ s) :

(x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal hs ⋯ a, x.coeff ij.1 * y.coeff ij.2

theorem HahnSeries.mul_coeff_right' {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} {a : Γ} {s : Set Γ} (hs : s.IsPWO) (hys : y.support ⊆ s) :

(x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal ⋯ hs a, x.coeff ij.1 * y.coeff ij.2

instance HahnSeries.instDistrib {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] :

Distrib (HahnSeries Γ R)

Equations

HahnSeries.instDistrib = let __src := inferInstanceAs (Mul (HahnSeries Γ R)); let __src_1 := inferInstanceAs (Add (HahnSeries Γ R)); Distrib.mk ⋯ ⋯

theorem HahnSeries.single_mul_coeff_add {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} {b : Γ} :

((HahnSeries.single b) r * x).coeff (a + b) = r * x.coeff a

theorem HahnSeries.mul_single_coeff_add {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} {b : Γ} :

(x * (HahnSeries.single b) r).coeff (a + b) = x.coeff a * r

@[simp]

theorem HahnSeries.mul_single_zero_coeff {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :

(x * (HahnSeries.single 0) r).coeff a = x.coeff a * r

theorem HahnSeries.single_zero_mul_coeff {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :

((HahnSeries.single 0) r * x).coeff a = r * x.coeff a

@[simp]

theorem HahnSeries.single_zero_mul_eq_smul {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [Semiring R] {r : R} {x : HahnSeries Γ R} :

(HahnSeries.single 0) r * x = r • x

theorem HahnSeries.support_mul_subset_add_support {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} :

(x * y).support ⊆ x.support + y.support

theorem HahnSeries.mul_coeff_order_add_order {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] (x : HahnSeries Γ R) (y : HahnSeries Γ R) :

(x * y).coeff (x.order + y.order) = x.leadingCoeff * y.leadingCoeff

instance HahnSeries.instNonUnitalNonAssocSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] :

NonUnitalNonAssocSemiring (HahnSeries Γ R)

Equations

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

instance HahnSeries.instNonUnitalSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalSemiring R] :

NonUnitalSemiring (HahnSeries Γ R)

Equations

HahnSeries.instNonUnitalSemiring = let __src := inferInstanceAs (NonUnitalNonAssocSemiring (HahnSeries Γ R)); NonUnitalSemiring.mk ⋯

instance HahnSeries.instNonAssocSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] :

NonAssocSemiring (HahnSeries Γ R)

Equations

HahnSeries.instNonAssocSemiring = let __src := AddMonoidWithOne.unary; let __src_1 := inferInstanceAs (NonUnitalNonAssocSemiring (HahnSeries Γ R)); NonAssocSemiring.mk ⋯ ⋯ ⋯ ⋯

instance HahnSeries.instSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [Semiring R] :

Semiring (HahnSeries Γ R)

Equations

HahnSeries.instSemiring = let __src := inferInstanceAs (NonAssocSemiring (HahnSeries Γ R)); let __src_1 := inferInstanceAs (NonUnitalSemiring (HahnSeries Γ R)); Semiring.mk ⋯ ⋯ ⋯ ⋯ npowRec ⋯ ⋯

instance HahnSeries.instNonUnitalCommSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalCommSemiring R] :

NonUnitalCommSemiring (HahnSeries Γ R)

Equations

HahnSeries.instNonUnitalCommSemiring = let __spread.0 := inferInstance; NonUnitalCommSemiring.mk ⋯

instance HahnSeries.instCommSemiring {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] :

CommSemiring (HahnSeries Γ R)

Equations

HahnSeries.instCommSemiring = let __src := inferInstanceAs (NonUnitalCommSemiring (HahnSeries Γ R)); let __src_1 := inferInstanceAs (Semiring (HahnSeries Γ R)); CommSemiring.mk ⋯

instance HahnSeries.instNonUnitalNonAssocRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocRing R] :

NonUnitalNonAssocRing (HahnSeries Γ R)

Equations

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

instance HahnSeries.instNonUnitalRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalRing R] :

NonUnitalRing (HahnSeries Γ R)

Equations

HahnSeries.instNonUnitalRing = let __src := inferInstanceAs (NonUnitalNonAssocRing (HahnSeries Γ R)); let __src_1 := inferInstanceAs (NonUnitalSemiring (HahnSeries Γ R)); NonUnitalRing.mk ⋯

instance HahnSeries.instNonAssocRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocRing R] :

NonAssocRing (HahnSeries Γ R)

Equations

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

instance HahnSeries.instRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [Ring R] :

Ring (HahnSeries Γ R)

Equations

HahnSeries.instRing = let __src := inferInstanceAs (Semiring (HahnSeries Γ R)); let __src_1 := inferInstanceAs (AddCommGroup (HahnSeries Γ R)); Ring.mk ⋯ SubNegMonoid.zsmul ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance HahnSeries.instNonUnitalCommRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalCommRing R] :

NonUnitalCommRing (HahnSeries Γ R)

Equations

HahnSeries.instNonUnitalCommRing = let __src := inferInstanceAs (NonUnitalCommSemiring (HahnSeries Γ R)); let __src_1 := inferInstanceAs (NonUnitalRing (HahnSeries Γ R)); NonUnitalCommRing.mk ⋯

instance HahnSeries.instCommRing {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommRing R] :

CommRing (HahnSeries Γ R)

Equations

HahnSeries.instCommRing = let __src := inferInstanceAs (CommSemiring (HahnSeries Γ R)); let __src_1 := inferInstanceAs (Ring (HahnSeries Γ R)); CommRing.mk ⋯

instance HahnModule.instBaseModule {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [PartialOrder Γ'] [AddCommMonoid V] [Semiring R] [Module R V] :

Module R (HahnModule Γ' R V)

Equations

HahnModule.instBaseModule = inferInstanceAs (Module R (HahnSeries Γ' V))

instance HahnModule.instModule {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} [OrderedCancelAddCommMonoid Γ] [PartialOrder Γ'] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] [AddCommMonoid V] [Semiring R] [Module R V] :

Module (HahnSeries Γ R) (HahnModule Γ' R V)

Equations

HahnModule.instModule = let __src := inferInstanceAs (DistribSMul (HahnSeries Γ R) (HahnModule Γ' R V)); Module.mk ⋯ ⋯

instance HahnModule.instNoZeroSMulDivisors {R : Type u_3} {V : Type u_4} [AddCommMonoid V] {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [Zero R] [SMulWithZero R V] [NoZeroSMulDivisors R V] :

NoZeroSMulDivisors (HahnSeries Γ R) (HahnModule Γ R V)

Equations

⋯ = ⋯

instance HahnSeries.instNoZeroDivisors {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] [NoZeroDivisors R] :

NoZeroDivisors (HahnSeries Γ R)

Equations

⋯ = ⋯

instance HahnSeries.instIsDomain {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R] :

IsDomain (HahnSeries Γ R)

Equations

⋯ = ⋯

theorem HahnSeries.orderTop_add_orderTop_le_orderTop_mul {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} :

x.orderTop + y.orderTop ≤ (x * y).orderTop

@[simp]

theorem HahnSeries.order_mul {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] [NoZeroDivisors R] {x : HahnSeries Γ R} {y : HahnSeries Γ R} (hx : x ≠ 0) (hy : y ≠ 0) :

(x * y).order = x.order + y.order

@[simp]

theorem HahnSeries.order_pow {R : Type u_3} {Γ : Type u_5} [LinearOrderedCancelAddCommMonoid Γ] [Semiring R] [NoZeroDivisors R] (x : HahnSeries Γ R) (n : ℕ) :

(x ^ n).order = n • x.order

@[simp]

theorem HahnSeries.single_mul_single {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] {a : Γ} {b : Γ} {r : R} {s : R} :

(HahnSeries.single a) r * (HahnSeries.single b) s = (HahnSeries.single (a + b)) (r * s)

@[simp]

theorem HahnSeries.single_pow {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [Semiring R] (a : Γ) (n : ℕ) (r : R) :

(HahnSeries.single a) r ^ n = (HahnSeries.single (n • a)) (r ^ n)

@[simp]

theorem HahnSeries.C_apply {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] (a : R) :

HahnSeries.C a = (HahnSeries.single 0) a

def HahnSeries.C {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] :

R →+* HahnSeries Γ R

C a is the constant Hahn Series a. C is provided as a ring homomorphism.

Equations

HahnSeries.C = { toFun := ⇑(HahnSeries.single 0), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

Instances For

theorem HahnSeries.C_zero {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] :

HahnSeries.C 0 = 0

theorem HahnSeries.C_one {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] :

HahnSeries.C 1 = 1

theorem HahnSeries.C_injective {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] :

Function.Injective ⇑HahnSeries.C

theorem HahnSeries.C_ne_zero {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] {r : R} (h : r ≠ 0) :

HahnSeries.C r ≠ 0

theorem HahnSeries.order_C {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [NonAssocSemiring R] {r : R} :

(HahnSeries.C r).order = 0

theorem HahnSeries.C_mul_eq_smul {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [Semiring R] {r : R} {x : HahnSeries Γ R} :

HahnSeries.C r * x = r • x

theorem HahnSeries.embDomain_mul {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] {Γ' : Type u_5} [OrderedCancelAddCommMonoid Γ'] [NonUnitalNonAssocSemiring R] (f : Γ ↪o Γ') (hf : ∀ (x y : Γ), f (x + y) = f x + f y) (x : HahnSeries Γ R) (y : HahnSeries Γ R) :

HahnSeries.embDomain f (x * y) = HahnSeries.embDomain f x * HahnSeries.embDomain f y

theorem HahnSeries.embDomain_one {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] {Γ' : Type u_5} [OrderedCancelAddCommMonoid Γ'] [NonAssocSemiring R] (f : Γ ↪o Γ') (hf : f 0 = 0) :

HahnSeries.embDomain f 1 = 1

@[simp]

theorem HahnSeries.embDomainRingHom_apply {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] {Γ' : Type u_5} [OrderedCancelAddCommMonoid Γ'] [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') :

∀ (a : HahnSeries Γ R), (HahnSeries.embDomainRingHom f hfi hf) a = HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ } a

def HahnSeries.embDomainRingHom {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] {Γ' : Type u_5} [OrderedCancelAddCommMonoid Γ'] [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') :

HahnSeries Γ R →+* HahnSeries Γ' R

Extending the domain of Hahn series is a ring homomorphism.

Equations

HahnSeries.embDomainRingHom f hfi hf = { toFun := HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

Instances For

theorem HahnSeries.embDomainRingHom_C {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] {Γ' : Type u_5} [OrderedCancelAddCommMonoid Γ'] [NonAssocSemiring R] {f : Γ →+ Γ'} {hfi : Function.Injective ⇑f} {hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g'} {r : R} :

(HahnSeries.embDomainRingHom f hfi hf) (HahnSeries.C r) = HahnSeries.C r

instance HahnSeries.instAlgebra {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] {A : Type u_5} [Semiring A] [Algebra R A] :

Algebra R (HahnSeries Γ A)

Equations

HahnSeries.instAlgebra = Algebra.mk (HahnSeries.C.comp (algebraMap R A)) ⋯ ⋯

theorem HahnSeries.C_eq_algebraMap {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] :

HahnSeries.C = algebraMap R (HahnSeries Γ R)

theorem HahnSeries.algebraMap_apply {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] {A : Type u_5} [Semiring A] [Algebra R A] {r : R} :

(algebraMap R (HahnSeries Γ A)) r = HahnSeries.C ((algebraMap R A) r)

instance HahnSeries.instNontrivialSubalgebra {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] [Nontrivial Γ] [Nontrivial R] :

Nontrivial (Subalgebra R (HahnSeries Γ R))

Equations

⋯ = ⋯

@[simp]

theorem HahnSeries.embDomainAlgHom_apply_coeff {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] {A : Type u_5} [Semiring A] [Algebra R A] {Γ' : Type u_6} [OrderedCancelAddCommMonoid Γ'] (f : Γ →+ Γ') (hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') :

∀ (a : HahnSeries Γ A) (b : Γ'), ((HahnSeries.embDomainAlgHom f hfi hf) a).coeff b = if h : ∃ (x : Γ), ¬a.coeff x = 0 ∧ f x = b then a.coeff (Classical.choose ⋯) else 0

def HahnSeries.embDomainAlgHom {Γ : Type u_1} {R : Type u_3} [OrderedCancelAddCommMonoid Γ] [CommSemiring R] {A : Type u_5} [Semiring A] [Algebra R A] {Γ' : Type u_6} [OrderedCancelAddCommMonoid Γ'] (f : Γ →+ Γ') (hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') :

HahnSeries Γ A →ₐ[R] HahnSeries Γ' A

Extending the domain of Hahn series is an algebra homomorphism.

Equations

HahnSeries.embDomainAlgHom f hfi hf = let __src := HahnSeries.embDomainRingHom f hfi hf; { toRingHom := __src, commutes' := ⋯ }

Instances For