File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

full_name: HahnSeries.instOne
code: instance [Zero R] [One R] : One (HahnSeries Γ R) 
goal: One (HahnSeries Γ R)

full_name: HahnSeries.one_coeff
code: @[simp]
theorem one_coeff [Zero R] [One R] {a : Γ} :
    (1 : HahnSeries Γ R).coeff a = if a = 0 then 1 else 0 
goal: HahnSeries.coeff 1 a = if a = 0 then 1 else 0

full_name: HahnSeries.single_zero_one
code: @[simp]
theorem single_zero_one [Zero R] [One R] : single (0 : Γ) (1 : R) = 1 
goal: (HahnSeries.single 0) 1 = 1

full_name: HahnSeries.support_one
code: @[simp]
theorem support_one [MulZeroOneClass R] [Nontrivial R] : support (1 : HahnSeries Γ R) = {0} 
goal: HahnSeries.support 1 = {0}

full_name: HahnSeries.orderTop_one
code: @[simp]
theorem orderTop_one [MulZeroOneClass R] [Nontrivial R] : orderTop (1 : HahnSeries Γ R) = 0 
goal: HahnSeries.orderTop 1 = 0

full_name: HahnSeries.order_one
code: @[simp]
theorem order_one [MulZeroOneClass R] : order (1 : HahnSeries Γ R) = 0 
goal: HahnSeries.order 1 = 0

full_name: HahnSeries.leadingCoeff_one
code: @[simp]
theorem leadingCoeff_one [MulZeroOneClass R] : (1 : HahnSeries Γ R).leadingCoeff = 1 
goal: HahnSeries.leadingCoeff 1 = 1

full_name: HahnModule
code: /-- 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. -/
@[nolint unusedArguments]
def HahnModule (Γ R V : Type*) [PartialOrder Γ] [Zero V] [SMul R V] 
goal: Type (max u_5 u_7)

full_name: HahnModule.of
code: /-- The casting function to the type synonym. -/
def of (R : Type*) [SMul R V] : HahnSeries Γ V ≃ HahnModule Γ R V 
goal: HahnSeries Γ V ≃ HahnModule Γ R V

full_name: HahnModule.rec
code: /-- Recursion principle to reduce a result about the synonym to the original type. -/
@[elab_as_elim]
def rec {motive : HahnModule Γ R V → Sort*} (h : ∀ x : HahnSeries Γ V, motive (of R x)) :
    ∀ x, motive x 
goal: motive x

full_name: HahnModule.ext
code: @[ext]
theorem ext (x y : HahnModule Γ R V) (h : ((of R).symm x).coeff = ((of R).symm y).coeff) : x = y 
goal: x = y

full_name: HahnModule.ext_iff
code: theorem ext_iff (x y : HahnModule Γ R V) :
    ((of R).symm x).coeff = ((of R).symm y).coeff ↔ x = y 
goal: ((HahnModule.of R).symm x).coeff = ((HahnModule.of R).symm y).coeff ↔ x = y

full_name: HahnModule.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (HahnModule Γ R V) 
goal: AddCommMonoid (HahnModule Γ R V)

full_name: HahnModule.instBaseSMul
code: instance instBaseSMul {V} [Monoid R] [AddMonoid V] [DistribMulAction R V] :
    SMul R (HahnModule Γ R V) 
goal: SMul R (HahnModule Γ R V)

full_name: HahnModule.of_zero
code: @[simp] theorem of_zero : of R (0 : HahnSeries Γ V) = 0 
goal: (HahnModule.of R) 0 = 0

full_name: HahnModule.of_add
code: @[simp] theorem of_add (x y : HahnSeries Γ V) : of R (x + y) = of R x + of R y 
goal: (HahnModule.of R) (x + y) = (HahnModule.of R) x + (HahnModule.of R) y

full_name: HahnModule.of_symm_zero
code: @[simp] theorem of_symm_zero : (of R).symm (0 : HahnModule Γ R V) = 0 
goal: (HahnModule.of R).symm 0 = 0

full_name: HahnModule.of_symm_add
code: @[simp] theorem of_symm_add (x y : HahnModule Γ R V) :
  (of R).symm (x + y) = (of R).symm x + (of R).symm y 
goal: (HahnModule.of R).symm (x + y) = (HahnModule.of R).symm x + (HahnModule.of R).symm y

full_name: HahnModule.instSMul
code: instance instSMul [Zero R] : SMul (HahnSeries Γ R) (HahnModule Γ' R V) 
goal: SMul (HahnSeries Γ R) (HahnModule Γ' R V)

full_name: HahnModule.smul_coeff
code: theorem smul_coeff [Zero R] (x : HahnSeries Γ R) (y : HahnModule Γ' R V) (a : Γ') :
    ((of R).symm <| x • y).coeff a =
      ∑ ij ∈ VAddAntidiagonal x.isPWO_support ((of R).symm y).isPWO_support a,
        x.coeff ij.fst • ((of R).symm y).coeff ij.snd 
goal: ((HahnModule.of R).symm (x • y)).coeff a =
  ∑ ij ∈ Finset.VAddAntidiagonal ⋯ ⋯ a, x.coeff ij.1 • ((HahnModule.of R).symm y).coeff ij.2

full_name: HahnModule.instBaseSMulZeroClass
code: instance instBaseSMulZeroClass [SMulZeroClass R V] :
    SMulZeroClass R (HahnModule Γ R V) 
goal: SMulZeroClass R (HahnModule Γ R V)

full_name: HahnModule.of_smul
code: @[simp] theorem of_smul [SMulZeroClass R V] (r : R) (x : HahnSeries Γ V) :
  (of R) (r • x) = r • (of R) x 
goal: (HahnModule.of R) (r • x) = r • (HahnModule.of R) x

full_name: HahnModule.of_symm_smul
code: @[simp] theorem of_symm_smul [PartialOrder Γ] [SMulZeroClass R V] (r : R) (x : HahnModule Γ R V) :
  (of R).symm (r • x) = r • (of R).symm x 
goal: (HahnModule.of R).symm (r • x) = r • (HahnModule.of R).symm x

full_name: HahnModule.instSMulZeroClass
code: instance instSMulZeroClass [SMulZeroClass R V] :
    SMulZeroClass (HahnSeries Γ R) (HahnModule Γ' R V) 
goal: SMulZeroClass (HahnSeries Γ R) (HahnModule Γ' R V)

full_name: HahnModule.smul_coeff_right
code: theorem smul_coeff_right [SMulZeroClass R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} {a : Γ'}
    {s : Set Γ'} (hs : s.IsPWO) (hys : ((of R).symm y).support ⊆ s) :
    ((of R).symm <| x • y).coeff a =
      ∑ ij ∈ VAddAntidiagonal x.isPWO_support hs a,
        x.coeff ij.fst • ((of R).symm y).coeff ij.snd 
goal: ((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

full_name: HahnModule.smul_coeff_left
code: theorem smul_coeff_left [SMulWithZero R V] {x : HahnSeries Γ R}
    {y : HahnModule Γ' R V} {a : Γ'} {s : Set Γ}
    (hs : s.IsPWO) (hxs : x.support ⊆ s) :
    ((of R).symm <| x • y).coeff a =
      ∑ ij ∈ VAddAntidiagonal hs ((of R).symm y).isPWO_support a,
        x.coeff ij.fst • ((of R).symm y).coeff ij.snd 
goal: ((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

full_name: HahnModule.smul_add
code: theorem smul_add [Zero R] [DistribSMul R V] (x : HahnSeries Γ R) (y z : HahnModule Γ' R V) :
    x • (y + z) = x • y + x • z 
goal: x • (y + z) = x • y + x • z

full_name: HahnModule.instDistribSMul
code: instance instDistribSMul [MonoidWithZero R] [DistribSMul R V] : DistribSMul (HahnSeries Γ R)
    (HahnModule Γ' R V) 
goal: DistribSMul (HahnSeries Γ R) (HahnModule Γ' R V)

full_name: HahnModule.add_smul
code: theorem add_smul [AddCommMonoid R] [SMulWithZero R V] {x 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 
goal: (x + y) • z = x • z + y • z

full_name: HahnModule.single_smul_coeff_add
code: theorem single_smul_coeff_add [MulZeroClass R] [SMulWithZero R V] {r : R} {x : HahnModule Γ' R V}
    {a : Γ'} {b : Γ} :
    ((of R).symm (HahnSeries.single b r • x)).coeff (b +ᵥ a) = r • ((of R).symm x).coeff a 
goal: ((HahnModule.of R).symm ((HahnSeries.single b) r • x)).coeff (b +ᵥ a) = r • ((HahnModule.of R).symm x).coeff a

full_name: HahnModule.single_zero_smul_coeff
code: theorem single_zero_smul_coeff {Γ} [OrderedAddCommMonoid Γ] [AddAction Γ Γ']
    [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
    {x : HahnModule Γ' R V} {a : Γ'} :
    ((of R).symm ((HahnSeries.single 0 r : HahnSeries Γ R) • x)).coeff a =
    r • ((of R).symm x).coeff a 
goal: ((HahnModule.of R).symm ((HahnSeries.single 0) r • x)).coeff a = r • ((HahnModule.of R).symm x).coeff a

full_name: HahnModule.single_zero_smul_eq_smul
code: @[simp]
theorem single_zero_smul_eq_smul (Γ) [OrderedAddCommMonoid Γ] [AddAction Γ Γ']
    [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
    {x : HahnModule Γ' R V} :
    (HahnSeries.single (0 : Γ) r) • x = r • x 
goal: (HahnSeries.single 0) r • x = r • x

full_name: HahnModule.zero_smul'
code: @[simp]
theorem zero_smul' [Zero R] [SMulWithZero R V] {x : HahnModule Γ' R V} :
    (0 : HahnSeries Γ R) • x = 0 
goal: 0 • x = 0

full_name: HahnModule.one_smul'
code: @[simp]
theorem one_smul' {Γ} [OrderedAddCommMonoid Γ] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ']
    [MonoidWithZero R] [MulActionWithZero R V] {x : HahnModule Γ' R V} :
    (1 : HahnSeries Γ R) • x = x 
goal: 1 • x = x

full_name: HahnModule.support_smul_subset_vadd_support'
code: theorem support_smul_subset_vadd_support' [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
    {y : HahnModule Γ' R V} :
    ((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support 
goal: ((HahnModule.of R).symm (x • y)).support ⊆ x.support +ᵥ ((HahnModule.of R).symm y).support

full_name: HahnModule.support_smul_subset_vadd_support
code: theorem support_smul_subset_vadd_support [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
    {y : HahnModule Γ' R V} :
    ((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support 
goal: ((HahnModule.of R).symm (x • y)).support ⊆ x.support +ᵥ ((HahnModule.of R).symm y).support

full_name: HahnModule.smul_coeff_order_add_order
code: theorem smul_coeff_order_add_order {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Zero R]
    [SMulWithZero R V] (x : HahnSeries Γ R) (y : HahnModule Γ R V) :
    ((of R).symm (x • y)).coeff (x.order + ((of R).symm y).order) =
    x.leadingCoeff • ((of R).symm y).leadingCoeff 
goal: ((HahnModule.of R).symm (x • y)).coeff (x.order + ((HahnModule.of R).symm y).order) =
  x.leadingCoeff • ((HahnModule.of R).symm y).leadingCoeff

full_name: HahnSeries.instMul
code: instance [NonUnitalNonAssocSemiring R] : Mul (HahnSeries Γ R) 
goal: Mul (HahnSeries Γ R)

full_name: HahnSeries.of_symm_smul_of_eq_mul
code: theorem of_symm_smul_of_eq_mul [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    (HahnModule.of R).symm (x • HahnModule.of R y) = x * y 
goal: (HahnModule.of R).symm (x • (HahnModule.of R) y) = x * y

full_name: HahnSeries.mul_coeff
code: theorem mul_coeff [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal x.isPWO_support y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd 
goal: (x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal ⋯ ⋯ a, x.coeff ij.1 * y.coeff ij.2

full_name: HahnSeries.mul_coeff_left'
code: theorem mul_coeff_left' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
    (hs : s.IsPWO) (hxs : x.support ⊆ s) :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal hs y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd 
goal: (x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal hs ⋯ a, x.coeff ij.1 * y.coeff ij.2

full_name: HahnSeries.mul_coeff_right'
code: theorem mul_coeff_right' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
    (hs : s.IsPWO) (hys : y.support ⊆ s) :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal x.isPWO_support hs a, x.coeff ij.fst * y.coeff ij.snd 
goal: (x * y).coeff a = ∑ ij ∈ Finset.addAntidiagonal ⋯ hs a, x.coeff ij.1 * y.coeff ij.2

full_name: HahnSeries.instDistrib
code: instance [NonUnitalNonAssocSemiring R] : Distrib (HahnSeries Γ R) 
goal: Distrib (HahnSeries Γ R)

full_name: HahnSeries.single_mul_coeff_add
code: theorem single_mul_coeff_add [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ}
    {b : Γ} : (single b r * x).coeff (a + b) = r * x.coeff a 
goal: ((HahnSeries.single b) r * x).coeff (a + b) = r * x.coeff a

full_name: HahnSeries.mul_single_coeff_add
code: theorem mul_single_coeff_add [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ}
    {b : Γ} : (x * single b r).coeff (a + b) = x.coeff a * r 
goal: (x * (HahnSeries.single b) r).coeff (a + b) = x.coeff a * r

full_name: HahnSeries.mul_single_zero_coeff
code: @[simp]
theorem mul_single_zero_coeff [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :
    (x * single 0 r).coeff a = x.coeff a * r 
goal: (x * (HahnSeries.single 0) r).coeff a = x.coeff a * r

full_name: HahnSeries.single_zero_mul_coeff
code: theorem single_zero_mul_coeff [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :
    ((single 0 r : HahnSeries Γ R) * x).coeff a = r * x.coeff a 
goal: ((HahnSeries.single 0) r * x).coeff a = r * x.coeff a

full_name: HahnSeries.single_zero_mul_eq_smul
code: @[simp]
theorem single_zero_mul_eq_smul [Semiring R] {r : R} {x : HahnSeries Γ R} :
    single 0 r * x = r • x 
goal: (HahnSeries.single 0) r * x = r • x

full_name: HahnSeries.support_mul_subset_add_support
code: theorem support_mul_subset_add_support [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    support (x * y) ⊆ support x + support y 
goal: (x * y).support ⊆ x.support + y.support

full_name: HahnSeries.mul_coeff_order_add_order
code: theorem mul_coeff_order_add_order {Γ} [LinearOrderedCancelAddCommMonoid Γ]
    [NonUnitalNonAssocSemiring R] (x y : HahnSeries Γ R) :
    (x * y).coeff (x.order + y.order) = x.leadingCoeff * y.leadingCoeff 
goal: (x * y).coeff (x.order + y.order) = x.leadingCoeff * y.leadingCoeff

full_name: _private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.mul_assoc'
code: private theorem mul_assoc' [NonUnitalSemiring R] (x y z : HahnSeries Γ R) :
    x * y * z = x * (y * z) 
goal: x * y * z = x * (y * z)

full_name: HahnSeries.instNonUnitalNonAssocSemiring
code: instance [NonUnitalNonAssocSemiring R] : NonUnitalNonAssocSemiring (HahnSeries Γ R) 
goal: NonUnitalNonAssocSemiring (HahnSeries Γ R)

full_name: HahnSeries.instNonUnitalSemiring
code: instance [NonUnitalSemiring R] : NonUnitalSemiring (HahnSeries Γ R) 
goal: NonUnitalSemiring (HahnSeries Γ R)

full_name: HahnSeries.instNonAssocSemiring
code: instance [NonAssocSemiring R] : NonAssocSemiring (HahnSeries Γ R) 
goal: NonAssocSemiring (HahnSeries Γ R)

full_name: HahnSeries.instSemiring
code: instance [Semiring R] : Semiring (HahnSeries Γ R) 
goal: Semiring (HahnSeries Γ R)

full_name: HahnSeries.instNonUnitalCommSemiring
code: instance [NonUnitalCommSemiring R] : NonUnitalCommSemiring (HahnSeries Γ R) 
goal: NonUnitalCommSemiring (HahnSeries Γ R)

full_name: HahnSeries.instCommSemiring
code: instance [CommSemiring R] : CommSemiring (HahnSeries Γ R) 
goal: CommSemiring (HahnSeries Γ R)

full_name: HahnSeries.instNonUnitalNonAssocRing
code: instance [NonUnitalNonAssocRing R] : NonUnitalNonAssocRing (HahnSeries Γ R) 
goal: NonUnitalNonAssocRing (HahnSeries Γ R)

full_name: HahnSeries.instNonUnitalRing
code: instance [NonUnitalRing R] : NonUnitalRing (HahnSeries Γ R) 
goal: NonUnitalRing (HahnSeries Γ R)

full_name: HahnSeries.instNonAssocRing
code: instance [NonAssocRing R] : NonAssocRing (HahnSeries Γ R) 
goal: NonAssocRing (HahnSeries Γ R)

full_name: HahnSeries.instRing
code: instance [Ring R] : Ring (HahnSeries Γ R) 
goal: Ring (HahnSeries Γ R)

full_name: HahnSeries.instNonUnitalCommRing
code: instance [NonUnitalCommRing R] : NonUnitalCommRing (HahnSeries Γ R) 
goal: NonUnitalCommRing (HahnSeries Γ R)

full_name: HahnSeries.instCommRing
code: instance [CommRing R] : CommRing (HahnSeries Γ R) 
goal: CommRing (HahnSeries Γ R)

full_name: _private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.mul_smul'
code: private theorem mul_smul' [Semiring R] [Module R V] (x y : HahnSeries Γ R)
    (z : HahnModule Γ' R V) : (x * y) • z = x • (y • z) 
goal: (x * y) • z = x • y • z

full_name: HahnModule.instBaseModule
code: instance instBaseModule [Semiring R] [Module R V] : Module R (HahnModule Γ' R V) 
goal: Module R (HahnModule Γ' R V)

full_name: HahnModule.instModule
code: instance instModule [Semiring R] [Module R V] : Module (HahnSeries Γ R)
    (HahnModule Γ' R V) 
goal: Module (HahnSeries Γ R) (HahnModule Γ' R V)

full_name: HahnModule.instNoZeroSMulDivisors
code: instance instNoZeroSMulDivisors {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Zero R]
    [SMulWithZero R V] [NoZeroSMulDivisors R V] :
    NoZeroSMulDivisors (HahnSeries Γ R) (HahnModule Γ R V) 
goal: NoZeroSMulDivisors (HahnSeries Γ R) (HahnModule Γ R V)

full_name: HahnSeries.instNoZeroDivisors
code: instance {Γ} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R] [NoZeroDivisors R] :
    NoZeroDivisors (HahnSeries Γ R) 
goal: NoZeroDivisors (HahnSeries Γ R)

full_name: HahnSeries.instIsDomain
code: instance {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R] :
    IsDomain (HahnSeries Γ R) 
goal: IsDomain (HahnSeries Γ R)

full_name: HahnSeries.orderTop_add_orderTop_le_orderTop_mul
code: theorem orderTop_add_orderTop_le_orderTop_mul {Γ} [LinearOrderedCancelAddCommMonoid Γ]
    [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    x.orderTop + y.orderTop ≤ (x * y).orderTop 
goal: x.orderTop + y.orderTop ≤ (x * y).orderTop

full_name: HahnSeries.order_mul
code: @[simp]
theorem order_mul {Γ} [LinearOrderedCancelAddCommMonoid Γ] [NonUnitalNonAssocSemiring R]
    [NoZeroDivisors R] {x y : HahnSeries Γ R} (hx : x ≠ 0) (hy : y ≠ 0) :
    (x * y).order = x.order + y.order 
goal: (x * y).order = x.order + y.order

full_name: HahnSeries.order_pow
code: @[simp]
theorem order_pow {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Semiring R] [NoZeroDivisors R]
    (x : HahnSeries Γ R) (n : ℕ) : (x ^ n).order = n • x.order 
goal: (x ^ n).order = n • x.order

full_name: HahnSeries.single_mul_single
code: @[simp]
theorem single_mul_single {a b : Γ} {r s : R} :
    single a r * single b s = single (a + b) (r * s) 
goal: (HahnSeries.single a) r * (HahnSeries.single b) s = (HahnSeries.single (a + b)) (r * s)

full_name: HahnSeries.single_pow
code: @[simp]
theorem single_pow (a : Γ) (n : ℕ) (r : R) : single a r ^ n = single (n • a) (r ^ n) 
goal: (HahnSeries.single a) r ^ n = (HahnSeries.single (n • a)) (r ^ n)

full_name: HahnSeries.C
code: /-- `C a` is the constant Hahn Series `a`. `C` is provided as a ring homomorphism. -/
@[simps]
def C : R →+* HahnSeries Γ R 
goal: R →+* HahnSeries Γ R

full_name: HahnSeries.C_apply
code: /-- `C a` is the constant Hahn Series `a`. `C` is provided as a ring homomorphism. -/
@[simps]
def C : R →+* HahnSeries Γ R 
goal: HahnSeries.C a = (HahnSeries.single 0) a

full_name: HahnSeries.C_zero
code: theorem C_zero : C (0 : R) = (0 : HahnSeries Γ R) 
goal: HahnSeries.C 0 = 0

full_name: HahnSeries.C_one
code: theorem C_one : C (1 : R) = (1 : HahnSeries Γ R) 
goal: HahnSeries.C 1 = 1

full_name: HahnSeries.C_injective
code: theorem C_injective : Function.Injective (C : R → HahnSeries Γ R) 
goal: Function.Injective ⇑HahnSeries.C

full_name: HahnSeries.C_ne_zero
code: theorem C_ne_zero {r : R} (h : r ≠ 0) : (C r : HahnSeries Γ R) ≠ 0 
goal: HahnSeries.C r ≠ 0

full_name: HahnSeries.order_C
code: theorem order_C {r : R} : order (C r : HahnSeries Γ R) = 0 
goal: (HahnSeries.C r).order = 0

full_name: HahnSeries.C_mul_eq_smul
code: theorem C_mul_eq_smul {r : R} {x : HahnSeries Γ R} : C r * x = r • x 
goal: HahnSeries.C r * x = r • x

full_name: HahnSeries.embDomain_mul
code: theorem embDomain_mul [NonUnitalNonAssocSemiring R] (f : Γ ↪o Γ')
    (hf : ∀ x y, f (x + y) = f x + f y) (x y : HahnSeries Γ R) :
    embDomain f (x * y) = embDomain f x * embDomain f y 
goal: HahnSeries.embDomain f (x * y) = HahnSeries.embDomain f x * HahnSeries.embDomain f y

full_name: HahnSeries.embDomain_one
code: theorem embDomain_one [NonAssocSemiring R] (f : Γ ↪o Γ') (hf : f 0 = 0) :
    embDomain f (1 : HahnSeries Γ R) = (1 : HahnSeries Γ' R) 
goal: HahnSeries.embDomain f 1 = 1

full_name: HahnSeries.embDomainRingHom
code: /-- Extending the domain of Hahn series is a ring homomorphism. -/
@[simps]
def embDomainRingHom [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ R →+* HahnSeries Γ' R 
goal: HahnSeries Γ R →+* HahnSeries Γ' R

full_name: HahnSeries.embDomainRingHom_apply
code: /-- Extending the domain of Hahn series is a ring homomorphism. -/
@[simps]
def embDomainRingHom [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ R →+* HahnSeries Γ' R 
goal: ∀ (a : HahnSeries Γ R),
  (HahnSeries.embDomainRingHom f hfi hf) a = HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ } a

full_name: HahnSeries.embDomainRingHom_C
code: theorem embDomainRingHom_C [NonAssocSemiring R] {f : Γ →+ Γ'} {hfi : Function.Injective f}
    {hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g'} {r : R} : embDomainRingHom f hfi hf (C r) = C r 
goal: (HahnSeries.embDomainRingHom f hfi hf) (HahnSeries.C r) = HahnSeries.C r

full_name: HahnSeries.instAlgebra
code: instance : Algebra R (HahnSeries Γ A) 
goal: Algebra R (HahnSeries Γ A)

full_name: HahnSeries.C_eq_algebraMap
code: theorem C_eq_algebraMap : C = algebraMap R (HahnSeries Γ R) 
goal: HahnSeries.C = algebraMap R (HahnSeries Γ R)

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

full_name: HahnSeries.instNontrivialSubalgebra
code: instance [Nontrivial Γ] [Nontrivial R] : Nontrivial (Subalgebra R (HahnSeries Γ R)) 
goal: Nontrivial (Subalgebra R (HahnSeries Γ R))

full_name: HahnSeries.embDomainAlgHom_apply_coeff
code: /-- Extending the domain of Hahn series is an algebra homomorphism. -/
@[simps!]
def embDomainAlgHom (f : Γ →+ Γ') (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ A →ₐ[R] HahnSeries Γ' A 
goal: ∀ (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

full_name: HahnSeries.embDomainAlgHom
code: /-- Extending the domain of Hahn series is an algebra homomorphism. -/
@[simps!]
def embDomainAlgHom (f : Γ →+ Γ') (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ A →ₐ[R] HahnSeries Γ' A 
goal: HahnSeries Γ A →ₐ[R] HahnSeries Γ' A