File: Mathlib/RingTheory/HahnSeries/Addition.lean

full_name: HahnSeries.instAdd
code: instance : Add (HahnSeries Γ R) 
goal: Add (HahnSeries Γ R)

full_name: HahnSeries.instAddMonoid
code: instance : AddMonoid (HahnSeries Γ R) 
goal: AddMonoid (HahnSeries Γ R)

full_name: HahnSeries.add_coeff'
code: @[simp]
theorem add_coeff' {x y : HahnSeries Γ R} : (x + y).coeff = x.coeff + y.coeff 
goal: (x + y).coeff = x.coeff + y.coeff

full_name: HahnSeries.add_coeff
code: theorem add_coeff {x y : HahnSeries Γ R} {a : Γ} : (x + y).coeff a = x.coeff a + y.coeff a 
goal: (x + y).coeff a = x.coeff a + y.coeff a

full_name: HahnSeries.addOppositeEquiv_symm_apply_coeff
code: /--
`addOppositeEquiv` is an additive monoid isomorphism between
Hahn series over `Γ` with coefficients in the opposite additive monoid `Rᵃᵒᵖ`
and the additive opposite of Hahn series over `Γ` with coefficients `R`.
-/
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ 
goal: (HahnSeries.addOppositeEquiv.symm x).coeff a = AddOpposite.op ((AddOpposite.unop x).coeff a)

full_name: HahnSeries.addOppositeEquiv_apply
code: /--
`addOppositeEquiv` is an additive monoid isomorphism between
Hahn series over `Γ` with coefficients in the opposite additive monoid `Rᵃᵒᵖ`
and the additive opposite of Hahn series over `Γ` with coefficients `R`.
-/
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ 
goal: HahnSeries.addOppositeEquiv x = AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ }

full_name: HahnSeries.addOppositeEquiv
code: /--
`addOppositeEquiv` is an additive monoid isomorphism between
Hahn series over `Γ` with coefficients in the opposite additive monoid `Rᵃᵒᵖ`
and the additive opposite of Hahn series over `Γ` with coefficients `R`.
-/
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ 
goal: HahnSeries Γ Rᵃᵒᵖ ≃+ (HahnSeries Γ R)ᵃᵒᵖ

full_name: HahnSeries.addOppositeEquiv_support
code: @[simp]
lemma addOppositeEquiv_support (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.support = x.support 
goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).support = x.support

full_name: HahnSeries.addOppositeEquiv_symm_support
code: @[simp]
lemma addOppositeEquiv_symm_support (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).support = x.unop.support 
goal: (HahnSeries.addOppositeEquiv.symm x).support = (AddOpposite.unop x).support

full_name: HahnSeries.addOppositeEquiv_orderTop
code: @[simp]
lemma addOppositeEquiv_orderTop (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.orderTop = x.orderTop 
goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).orderTop = x.orderTop

full_name: HahnSeries.addOppositeEquiv_symm_orderTop
code: @[simp]
lemma addOppositeEquiv_symm_orderTop (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).orderTop = x.unop.orderTop 
goal: (HahnSeries.addOppositeEquiv.symm x).orderTop = (AddOpposite.unop x).orderTop

full_name: HahnSeries.addOppositeEquiv_leadingCoeff
code: @[simp]
lemma addOppositeEquiv_leadingCoeff (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.leadingCoeff = x.leadingCoeff.unop 
goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).leadingCoeff = AddOpposite.unop x.leadingCoeff

full_name: HahnSeries.addOppositeEquiv_symm_leadingCoeff
code: @[simp]
lemma addOppositeEquiv_symm_leadingCoeff (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).leadingCoeff = .op x.unop.leadingCoeff 
goal: (HahnSeries.addOppositeEquiv.symm x).leadingCoeff = AddOpposite.op (AddOpposite.unop x).leadingCoeff

full_name: HahnSeries.support_add_subset
code: theorem support_add_subset {x y : HahnSeries Γ R} : support (x + y) ⊆ support x ∪ support y 
goal: (x + y).support ⊆ x.support ∪ y.support

full_name: HahnSeries.min_le_min_add
code: protected theorem min_le_min_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} (hx : x ≠ 0)
    (hy : y ≠ 0) (hxy : x + y ≠ 0) :
    min (Set.IsWF.min x.isWF_support (support_nonempty_iff.2 hx))
      (Set.IsWF.min y.isWF_support (support_nonempty_iff.2 hy)) ≤
      Set.IsWF.min (x + y).isWF_support (support_nonempty_iff.2 hxy) 
goal: min (⋯.min ⋯) (⋯.min ⋯) ≤ ⋯.min ⋯

full_name: HahnSeries.min_orderTop_le_orderTop_add
code: theorem min_orderTop_le_orderTop_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
    min x.orderTop y.orderTop ≤ (x + y).orderTop 
goal: min x.orderTop y.orderTop ≤ (x + y).orderTop

full_name: HahnSeries.min_order_le_order_add
code: theorem min_order_le_order_add {Γ} [Zero Γ] [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x + y ≠ 0) : min x.order y.order ≤ (x + y).order 
goal: min x.order y.order ≤ (x + y).order

full_name: HahnSeries.orderTop_add_eq_left
code: theorem orderTop_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x + y).orderTop = x.orderTop 
goal: (x + y).orderTop = x.orderTop

full_name: HahnSeries.orderTop_add_eq_right
code: theorem orderTop_add_eq_right {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : y.orderTop < x.orderTop) : (x + y).orderTop = y.orderTop 
goal: (x + y).orderTop = y.orderTop

full_name: HahnSeries.leadingCoeff_add_eq_left
code: theorem leadingCoeff_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x + y).leadingCoeff = x.leadingCoeff 
goal: (x + y).leadingCoeff = x.leadingCoeff

full_name: HahnSeries.leadingCoeff_add_eq_right
code: theorem leadingCoeff_add_eq_right {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : y.orderTop < x.orderTop) : (x + y).leadingCoeff = y.leadingCoeff 
goal: (x + y).leadingCoeff = y.leadingCoeff

full_name: HahnSeries.single.addMonoidHom
code: /-- `single` as an additive monoid/group homomorphism -/
@[simps!]
def single.addMonoidHom (a : Γ) : R →+ HahnSeries Γ R 
goal: R →+ HahnSeries Γ R

full_name: HahnSeries.single.addMonoidHom_apply_coeff
code: /-- `single` as an additive monoid/group homomorphism -/
@[simps!]
def single.addMonoidHom (a : Γ) : R →+ HahnSeries Γ R 
goal: ((HahnSeries.single.addMonoidHom a) r).coeff j = Pi.single a r j

full_name: HahnSeries.coeff.addMonoidHom
code: /-- `coeff g` as an additive monoid/group homomorphism -/
@[simps]
def coeff.addMonoidHom (g : Γ) : HahnSeries Γ R →+ R 
goal: HahnSeries Γ R →+ R

full_name: HahnSeries.coeff.addMonoidHom_apply
code: /-- `coeff g` as an additive monoid/group homomorphism -/
@[simps]
def coeff.addMonoidHom (g : Γ) : HahnSeries Γ R →+ R 
goal: (HahnSeries.coeff.addMonoidHom g) f = f.coeff g

full_name: HahnSeries.embDomain_add
code: theorem embDomain_add (f : Γ ↪o Γ') (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.instAddCommMonoid
code: instance [AddCommMonoid R] : AddCommMonoid (HahnSeries Γ R) 
goal: AddCommMonoid (HahnSeries Γ R)

full_name: HahnSeries.instNeg
code: instance : Neg (HahnSeries Γ R) 
goal: Neg (HahnSeries Γ R)

full_name: HahnSeries.instAddGroup
code: instance : AddGroup (HahnSeries Γ R) 
goal: AddGroup (HahnSeries Γ R)

full_name: HahnSeries.neg_coeff'
code: @[simp]
theorem neg_coeff' {x : HahnSeries Γ R} : (-x).coeff = -x.coeff 
goal: (-x).coeff = -x.coeff

full_name: HahnSeries.neg_coeff
code: theorem neg_coeff {x : HahnSeries Γ R} {a : Γ} : (-x).coeff a = -x.coeff a 
goal: (-x).coeff a = -x.coeff a

full_name: HahnSeries.support_neg
code: @[simp]
theorem support_neg {x : HahnSeries Γ R} : (-x).support = x.support 
goal: (-x).support = x.support

full_name: HahnSeries.sub_coeff'
code: @[simp]
theorem sub_coeff' {x y : HahnSeries Γ R} : (x - y).coeff = x.coeff - y.coeff 
goal: (x - y).coeff = x.coeff - y.coeff

full_name: HahnSeries.sub_coeff
code: theorem sub_coeff {x y : HahnSeries Γ R} {a : Γ} : (x - y).coeff a = x.coeff a - y.coeff a 
goal: (x - y).coeff a = x.coeff a - y.coeff a

full_name: HahnSeries.orderTop_neg
code: theorem orderTop_neg {x : HahnSeries Γ R} : (-x).orderTop = x.orderTop 
goal: (-x).orderTop = x.orderTop

full_name: HahnSeries.order_neg
code: @[simp]
theorem order_neg [Zero Γ] {f : HahnSeries Γ R} : (-f).order = f.order 
goal: (-f).order = f.order

full_name: HahnSeries.min_orderTop_le_orderTop_sub
code: theorem min_orderTop_le_orderTop_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
    min x.orderTop y.orderTop ≤ (x - y).orderTop 
goal: min x.orderTop y.orderTop ≤ (x - y).orderTop

full_name: HahnSeries.orderTop_sub
code: theorem orderTop_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x - y).orderTop = x.orderTop 
goal: (x - y).orderTop = x.orderTop

full_name: HahnSeries.leadingCoeff_sub
code: theorem leadingCoeff_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x - y).leadingCoeff = x.leadingCoeff 
goal: (x - y).leadingCoeff = x.leadingCoeff

full_name: HahnSeries.instAddCommGroup
code: instance [AddCommGroup R] : AddCommGroup (HahnSeries Γ R) 
goal: AddCommGroup (HahnSeries Γ R)

full_name: HahnSeries.instSMul
code: instance : SMul R (HahnSeries Γ V) 
goal: SMul R (HahnSeries Γ V)

full_name: HahnSeries.smul_coeff
code: @[simp]
theorem smul_coeff {r : R} {x : HahnSeries Γ V} {a : Γ} : (r • x).coeff a = r • x.coeff a 
goal: (r • x).coeff a = r • x.coeff a

full_name: HahnSeries.instSMulZeroClass
code: instance : SMulZeroClass R (HahnSeries Γ V) 
goal: SMulZeroClass R (HahnSeries Γ V)

full_name: HahnSeries.orderTop_smul_not_lt
code: theorem orderTop_smul_not_lt (r : R) (x : HahnSeries Γ V) : ¬ (r • x).orderTop < x.orderTop 
goal: ¬(r • x).orderTop < x.orderTop

full_name: HahnSeries.order_smul_not_lt
code: theorem order_smul_not_lt [Zero Γ] (r : R) (x : HahnSeries Γ V) (h : r • x ≠ 0) :
    ¬ (r • x).order < x.order 
goal: ¬(r • x).order < x.order

full_name: HahnSeries.le_order_smul
code: theorem le_order_smul {Γ} [Zero Γ] [LinearOrder Γ] (r : R) (x : HahnSeries Γ V) (h : r • x ≠ 0) :
    x.order ≤ (r • x).order 
goal: x.order ≤ (r • x).order

full_name: HahnSeries.instDistribMulAction
code: instance : DistribMulAction R (HahnSeries Γ V) 
goal: DistribMulAction R (HahnSeries Γ V)

full_name: HahnSeries.instIsScalarTower
code: instance [SMul R S] [IsScalarTower R S V] : IsScalarTower R S (HahnSeries Γ V) 
goal: IsScalarTower R S (HahnSeries Γ V)

full_name: HahnSeries.instSMulCommClass
code: instance [SMulCommClass R S V] : SMulCommClass R S (HahnSeries Γ V) 
goal: SMulCommClass R S (HahnSeries Γ V)

full_name: HahnSeries.instModule
code: instance : Module R (HahnSeries Γ V) 
goal: Module R (HahnSeries Γ V)

full_name: HahnSeries.single.linearMap_apply
code: /-- `single` as a linear map -/
@[simps]
def single.linearMap (a : Γ) : V →ₗ[R] HahnSeries Γ V 
goal: ∀ (a_1 : V), (HahnSeries.single.linearMap a) a_1 = (↑(HahnSeries.single.addMonoidHom a)).toFun a_1

full_name: HahnSeries.single.linearMap
code: /-- `single` as a linear map -/
@[simps]
def single.linearMap (a : Γ) : V →ₗ[R] HahnSeries Γ V 
goal: V →ₗ[R] HahnSeries Γ V

full_name: HahnSeries.coeff.linearMap_apply
code: /-- `coeff g` as a linear map -/
@[simps]
def coeff.linearMap (g : Γ) : HahnSeries Γ V →ₗ[R] V 
goal: ∀ (a : HahnSeries Γ V), (HahnSeries.coeff.linearMap g) a = (↑(HahnSeries.coeff.addMonoidHom g)).toFun a

full_name: HahnSeries.coeff.linearMap
code: /-- `coeff g` as a linear map -/
@[simps]
def coeff.linearMap (g : Γ) : HahnSeries Γ V →ₗ[R] V 
goal: HahnSeries Γ V →ₗ[R] V

full_name: HahnSeries.embDomain_smul
code: theorem embDomain_smul (f : Γ ↪o Γ') (r : R) (x : HahnSeries Γ R) :
    embDomain f (r • x) = r • embDomain f x 
goal: HahnSeries.embDomain f (r • x) = r • HahnSeries.embDomain f x

full_name: HahnSeries.embDomainLinearMap_apply
code: /-- Extending the domain of Hahn series is a linear map. -/
@[simps]
def embDomainLinearMap (f : Γ ↪o Γ') : HahnSeries Γ R →ₗ[R] HahnSeries Γ' R 
goal: ∀ (a : HahnSeries Γ R), (HahnSeries.embDomainLinearMap f) a = HahnSeries.embDomain f a

full_name: HahnSeries.embDomainLinearMap
code: /-- Extending the domain of Hahn series is a linear map. -/
@[simps]
def embDomainLinearMap (f : Γ ↪o Γ') : HahnSeries Γ R →ₗ[R] HahnSeries Γ' R 
goal: HahnSeries Γ R →ₗ[R] HahnSeries Γ' R