File: Mathlib/GroupTheory/GroupAction/Hom.lean

full_name: MulActionHom.map_smul'
code: /-- Equivariant functions :
When `φ : M → N` is a function, and types `X` and `Y` are endowed with actions of `M` and `N`,
a function `f : X → Y` is `φ`-equivariant if `f (m • x) = (φ m) • (f x)`.  -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure MulActionHom where
  /-- The underlying function. -/
  protected toFun : X → Y
  /-- The proposition that the function commutes with the actions. -/
  protected map_smul' : ∀ (m : M) (x : X), toFun (m • x) = (φ m) • toFun x
goal: self.toFun (m • x) = φ m • self.toFun x

full_name: MulActionHom
code: /-- Equivariant functions :
When `φ : M → N` is a function, and types `X` and `Y` are endowed with actions of `M` and `N`,
a function `f : X → Y` is `φ`-equivariant if `f (m • x) = (φ m) • (f x)`.  -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure MulActionHom where
  /-- The underlying function. -/
  protected toFun : X → Y
  /-- The proposition that the function commutes with the actions. -/
  protected map_smul' : ∀ (m : M) (x : X), toFun (m • x) = (φ m) • toFun x
goal: Type (max u_5 u_6)

full_name: MulActionHom.toFun
code: /-- Equivariant functions :
When `φ : M → N` is a function, and types `X` and `Y` are endowed with actions of `M` and `N`,
a function `f : X → Y` is `φ`-equivariant if `f (m • x) = (φ m) • (f x)`.  -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure MulActionHom where
  /-- The underlying function. -/
  protected toFun : X → Y
  /-- The proposition that the function commutes with the actions. -/
  protected map_smul' : ∀ (m : M) (x : X), toFun (m • x) = (φ m) • toFun x
goal: X → Y

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulActionHom_1
code: /-- `φ`-equivariant functions `X → Y`,
where `φ : M → N`, where `M` and `N` act on `X` and `Y` respectively -/
notation:25 (name := «MulActionHomLocal≺») X " →ₑ[" φ:25 "] " Y:0 => MulActionHom φ X Y
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_MulActionHomLocal≺_1»
code: /-- `φ`-equivariant functions `X → Y`,
where `φ : M → N`, where `M` and `N` act on `X` and `Y` respectively -/
notation:25 (name := «MulActionHomLocal≺») X " →ₑ[" φ:25 "] " Y:0 => MulActionHom φ X Y
goal: Lean.Macro

full_name: «MulActionHomLocal≺»
code: /-- `φ`-equivariant functions `X → Y`,
where `φ : M → N`, where `M` and `N` act on `X` and `Y` respectively -/
notation:25 (name := «MulActionHomLocal≺») X " →ₑ[" φ:25 "] " Y:0 => MulActionHom φ X Y
goal: Lean.TrailingParserDescr

full_name: «MulActionHomIdLocal≺»
code: /-- `M`-equivariant functions `X → Y` with respect to the action of `M`

This is the same as `X →ₑ[@id M] Y` -/
notation:25 (name := «MulActionHomIdLocal≺») X " →[" M:25 "] " Y:0 => MulActionHom (@id M) X Y
goal: Lean.TrailingParserDescr

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_MulActionHomIdLocal≺_1»
code: /-- `M`-equivariant functions `X → Y` with respect to the action of `M`

This is the same as `X →ₑ[@id M] Y` -/
notation:25 (name := «MulActionHomIdLocal≺») X " →[" M:25 "] " Y:0 => MulActionHom (@id M) X Y
goal: Lean.Macro

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulActionHom_2
code: /-- `M`-equivariant functions `X → Y` with respect to the action of `M`

This is the same as `X →ₑ[@id M] Y` -/
notation:25 (name := «MulActionHomIdLocal≺») X " →[" M:25 "] " Y:0 => MulActionHom (@id M) X Y
goal: Lean.PrettyPrinter.Unexpander

full_name: MulActionSemiHomClass.map_smulₛₗ
code: /-- `MulActionSemiHomClass F φ X Y` states that
  `F` is a type of morphisms which are `φ`-equivariant.

You should extend this class when you extend `MulActionHom`. -/
class MulActionSemiHomClass (F : Type*)
    {M N : outParam Type*} (φ : outParam (M → N))
    (X Y : outParam Type*) [SMul M X] [SMul N Y] [FunLike F X Y] : Prop where
  /-- The proposition that the function preserves the action. -/
  map_smulₛₗ : ∀ (f : F) (c : M) (x : X), f (c • x) = (φ c) • (f x)
goal: f (c • x) = φ c • f x

full_name: MulActionSemiHomClass
code: /-- `MulActionSemiHomClass F φ X Y` states that
  `F` is a type of morphisms which are `φ`-equivariant.

You should extend this class when you extend `MulActionHom`. -/
class MulActionSemiHomClass (F : Type*)
    {M N : outParam Type*} (φ : outParam (M → N))
    (X Y : outParam Type*) [SMul M X] [SMul N Y] [FunLike F X Y] : Prop where
  /-- The proposition that the function preserves the action. -/
  map_smulₛₗ : ∀ (f : F) (c : M) (x : X), f (c • x) = (φ c) • (f x)
goal: Prop

full_name: MulActionHomClass
code: /-- `MulActionHomClass F M X Y` states that `F` is a type of
morphisms which are equivariant with respect to actions of `M`
This is an abbreviation of `MulActionSemiHomClass`. -/
abbrev MulActionHomClass (F : Type*) (M : outParam Type*)
    (X Y : outParam Type*) [SMul M X] [SMul M Y] [FunLike F X Y] 
goal: Prop

full_name: instFunLikeMulActionHom
code: instance : FunLike (MulActionHom φ X Y) X Y 
goal: FunLike (X →ₑ[φ] Y) X Y

full_name: map_smul
code: @[simp]
theorem map_smul {F M X Y : Type*} [SMul M X] [SMul M Y]
    [FunLike F X Y] [MulActionHomClass F M X Y]
    (f : F) (c : M) (x : X) : f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: instMulActionSemiHomClassMulActionHom
code: instance : MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y 
goal: MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y

full_name: MulActionSemiHomClass.toMulActionHom
code: /-- Turn an element of a type `F` satisfying `MulActionSemiHomClass F φ X Y`
  into an actual `MulActionHom`.
  This is declared as the default coercion from `F` to `MulActionSemiHom φ X Y`. -/
@[coe]
def _root_.MulActionSemiHomClass.toMulActionHom [MulActionSemiHomClass F φ X Y] (f : F) :
    X →ₑ[φ] Y 
goal: X →ₑ[φ] Y

full_name: MulActionHom.instCoeTCOfMulActionSemiHomClass
code: /-- Any type satisfying `MulActionSemiHomClass` can be cast into `MulActionHom` via
  `MulActionHomSemiClass.toMulActionHom`. -/
instance [MulActionSemiHomClass F φ X Y] : CoeTC F (X →ₑ[φ] Y) 
goal: CoeTC F (X →ₑ[φ] Y)

full_name: IsScalarTower.smulHomClass
code: /-- If Y/X/M forms a scalar tower, any map X → Y preserving X-action also preserves M-action. -/
theorem _root_.IsScalarTower.smulHomClass [MulOneClass X] [SMul X Y] [IsScalarTower M' X Y]
    [MulActionHomClass F X X Y] : MulActionHomClass F M' X Y 
goal: MulActionHomClass F M' X Y

full_name: MulActionHom.map_smul
code: protected theorem map_smul (f : X →[M'] Y) (m : M') (x : X) : f (m • x) = m • f x 
goal: f (m • x) = m • f x

full_name: MulActionHom.ext
code: @[ext]
theorem ext {f g : X →ₑ[φ] Y} :
    (∀ x, f x = g x) → f = g 
goal: (∀ (x : X), f x = g x) → f = g

full_name: MulActionHom.ext_iff
code: protected theorem ext_iff  {f g : X →ₑ[φ] Y} :
    f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : X), f x = g x

full_name: MulActionHom.congr_fun
code: protected theorem congr_fun {f g : X →ₑ[φ] Y} (h : f = g) (x : X) :
    f x = g x 
goal: f x = g x

full_name: MulActionHom.ofEq
code: /-- Two equal maps on scalars give rise to an equivariant map for identity -/
def ofEq {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) : X →ₑ[φ'] Y 
goal: X →ₑ[φ'] Y

full_name: MulActionHom.ofEq_coe
code: @[simp]
theorem ofEq_coe {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) :
    (f.ofEq h).toFun = f.toFun 
goal: (MulActionHom.ofEq h f).toFun = f.toFun

full_name: MulActionHom.ofEq_apply
code: @[simp]
theorem ofEq_apply {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) (a : X) :
    (f.ofEq h) a = f a 
goal: (MulActionHom.ofEq h f) a = f a

full_name: MulActionHom.id
code: /-- The identity map as an equivariant map. -/
protected def id : X →[M] X 
goal: X →ₑ[id] X

full_name: MulActionHom.id_apply
code: @[simp]
theorem id_apply (x : X) :
    MulActionHom.id M x = x 
goal: (MulActionHom.id M) x = x

full_name: MulActionHom.comp
code: /-- Composition of two equivariant maps. -/
def comp (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y) [κ : CompTriple φ ψ χ] :
    X →ₑ[χ] Z 
goal: X →ₑ[χ] Z

full_name: MulActionHom.comp_apply
code: @[simp]
theorem comp_apply
    (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y) [CompTriple φ ψ χ] (x : X) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: MulActionHom.id_comp
code: @[simp]
theorem id_comp (f : X →ₑ[φ] Y) :
    (MulActionHom.id N).comp f = f 
goal: (MulActionHom.id N).comp f = f

full_name: MulActionHom.comp_id
code: @[simp]
theorem comp_id (f : X →ₑ[φ] Y) :
    f.comp (MulActionHom.id M) = f 
goal: f.comp (MulActionHom.id M) = f

full_name: MulActionHom.comp_assoc
code: @[simp]
theorem comp_assoc {Q T : Type*} [SMul Q T]
    {η : P → Q} {θ : M → Q} {ζ : N → Q}
    (h : Z →ₑ[η] T) (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y)
    [CompTriple φ ψ χ] [CompTriple χ η θ]
    [CompTriple ψ η ζ] [CompTriple φ ζ θ] :
    h.comp (g.comp f) = (h.comp g).comp f 
goal: h.comp (g.comp f) = (h.comp g).comp f

full_name: MulActionHom.inverse
code: /-- The inverse of a bijective equivariant map is equivariant. -/
@[simps]
def inverse (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : Y₁ →[M] X 
goal: Y₁ →ₑ[id] X

full_name: MulActionHom.inverse_apply
code: /-- The inverse of a bijective equivariant map is equivariant. -/
@[simps]
def inverse (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : Y₁ →[M] X 
goal: ∀ (a : Y₁), (f.inverse g h₁ h₂) a = g a

full_name: MulActionHom.inverse'_apply
code: /-- The inverse of a bijective equivariant map is equivariant. -/
@[simps]
def inverse' (f : X →ₑ[φ] Y) (g : Y → X) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    Y →ₑ[φ'] X 
goal: ∀ (a : Y), (f.inverse' g k h₁ h₂) a = g a

full_name: MulActionHom.inverse'
code: /-- The inverse of a bijective equivariant map is equivariant. -/
@[simps]
def inverse' (f : X →ₑ[φ] Y) (g : Y → X) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    Y →ₑ[φ'] X 
goal: Y →ₑ[φ'] X

full_name: MulActionHom.inverse_eq_inverse'
code: lemma inverse_eq_inverse' (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
  inverse f g h₁ h₂ =  inverse' f g (congrFun rfl) h₁ h₂ 
goal: f.inverse g h₁ h₂ = f.inverse' g ⋯ h₁ h₂

full_name: MulActionHom.inverse'_inverse'
code: theorem inverse'_inverse'
    {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    inverse' (inverse' f g k₂ h₁ h₂) f k₁ h₂ h₁ = f 
goal: (f.inverse' g k₂ h₁ h₂).inverse' (⇑f) k₁ h₂ h₁ = f

full_name: MulActionHom.comp_inverse'
code: theorem comp_inverse' {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    (inverse' f g k₂ h₁ h₂).comp f (κ := CompTriple.comp_inv k₁)
      = MulActionHom.id M 
goal: (f.inverse' g k₂ h₁ h₂).comp f = MulActionHom.id M

full_name: MulActionHom.inverse'_comp
code: theorem inverse'_comp {f : X →ₑ[φ] Y} {g : Y → X}
    {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    f.comp (inverse' f g k₂ h₁ h₂) (κ := CompTriple.comp_inv k₂) = MulActionHom.id N 
goal: f.comp (f.inverse' g k₂ h₁ h₂) = MulActionHom.id N

full_name: SMulCommClass.toMulActionHom
code: /-- If actions of `M` and `N` on `α` commute,
  then for `c : M`, `(c • · : α → α)` is an `N`-action homomorphism. -/
@[simps]
def _root_.SMulCommClass.toMulActionHom {M} (N α : Type*)
    [SMul M α] [SMul N α] [SMulCommClass M N α] (c : M) :
    α →[N] α 
goal: α →ₑ[id] α

full_name: SMulCommClass.toMulActionHom_apply
code: /-- If actions of `M` and `N` on `α` commute,
  then for `c : M`, `(c • · : α → α)` is an `N`-action homomorphism. -/
@[simps]
def _root_.SMulCommClass.toMulActionHom {M} (N α : Type*)
    [SMul M α] [SMul N α] [SMulCommClass M N α] (c : M) :
    α →[N] α 
goal: ∀ (x : α), (SMulCommClass.toMulActionHom N α c) x = c • x

full_name: DistribMulActionHom
code: /-- Equivariant additive monoid homomorphisms. -/
structure DistribMulActionHom extends A →ₑ[φ] B, A →+ B
goal: Type (max u_4 u_5)

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_DistribMulActionHomLocal≺_1»
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomLocal≺»)
  A " →ₑ+[" φ:25 "] " B:0 => DistribMulActionHom φ A B
goal: Lean.Macro

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_DistribMulActionHom_1
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomLocal≺»)
  A " →ₑ+[" φ:25 "] " B:0 => DistribMulActionHom φ A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «DistribMulActionHomLocal≺»
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomLocal≺»)
  A " →ₑ+[" φ:25 "] " B:0 => DistribMulActionHom φ A B
goal: Lean.TrailingParserDescr

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_DistribMulActionHom_2
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomIdLocal≺»)
  A " →+[" M:25 "] " B:0 => DistribMulActionHom (MonoidHom.id M) A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «DistribMulActionHomIdLocal≺»
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomIdLocal≺»)
  A " →+[" M:25 "] " B:0 => DistribMulActionHom (MonoidHom.id M) A B
goal: Lean.TrailingParserDescr

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_DistribMulActionHomIdLocal≺_1»
code: @[inherit_doc]
notation:25 (name := «DistribMulActionHomIdLocal≺»)
  A " →+[" M:25 "] " B:0 => DistribMulActionHom (MonoidHom.id M) A B
goal: Lean.Macro

full_name: DistribMulActionSemiHomClass
code: /-- `DistribMulActionSemiHomClass F φ A B` states that `F` is a type of morphisms
  preserving the additive monoid structure and equivariant with respect to `φ`.
    You should extend this class when you extend `DistribMulActionSemiHom`. -/
class DistribMulActionSemiHomClass (F : Type*)
    {M N : outParam Type*} (φ : outParam (M → N))
    (A B : outParam Type*)
    [Monoid M] [Monoid N]
    [AddMonoid A] [AddMonoid B] [DistribMulAction M A] [DistribMulAction N B]
    [FunLike F A B]
    extends MulActionSemiHomClass F φ A B, AddMonoidHomClass F A B : Prop
goal: Prop

full_name: DistribMulActionHomClass
code: /-- `DistribMulActionHomClass F M A B` states that `F` is a type of morphisms preserving
  the additive monoid structure and equivariant with respect to the action of `M`.
    It is an abbreviation to `DistribMulActionHomClass F (MonoidHom.id M) A B`
You should extend this class when you extend `DistribMulActionHom`. -/
abbrev DistribMulActionHomClass (F : Type*) (M : outParam Type*)
    (A B : outParam Type*) [Monoid M] [AddMonoid A] [AddMonoid B]
    [DistribMulAction M A] [DistribMulAction M B] [FunLike F A B] 
goal: Prop

full_name: DistribMulActionHom.instFunLike
code: instance : FunLike (A →ₑ+[φ] B) A B 
goal: FunLike (A →ₑ+[φ] B) A B

full_name: DistribMulActionHom.instDistribMulActionSemiHomClassCoeMonoidHom
code: instance : DistribMulActionSemiHomClass (A →ₑ+[φ] B) φ A B 
goal: DistribMulActionSemiHomClass (A →ₑ+[φ] B) (⇑φ) A B

full_name: DistribMulActionSemiHomClass.toDistribMulActionHom
code: /-- Turn an element of a type `F` satisfying `MulActionHomClass F M X Y` into an actual
`MulActionHom`. This is declared as the default coercion from `F` to `MulActionHom M X Y`. -/
@[coe]
def _root_.DistribMulActionSemiHomClass.toDistribMulActionHom
    [DistribMulActionSemiHomClass F φ A B]
    (f : F) : A →ₑ+[φ] B 
goal: A →ₑ+[φ] B

full_name: DistribMulActionHom.instCoeTCOfDistribMulActionSemiHomClassCoeMonoidHom
code: /-- Any type satisfying `MulActionHomClass` can be cast into `MulActionHom`
via `MulActionHomClass.toMulActionHom`. -/
instance [DistribMulActionSemiHomClass F φ A B] :
  CoeTC F (A →ₑ+[φ] B) 
goal: CoeTC F (A →ₑ+[φ] B)

full_name: SMulCommClass.toDistribMulActionHom_toFun
code: /-- If `DistribMulAction` of `M` and `N` on `A` commute,
  then for each `c : M`, `(c • ·)` is an `N`-action additive homomorphism. -/
@[simps]
def _root_.SMulCommClass.toDistribMulActionHom {M} (N A : Type*) [Monoid N] [AddMonoid A]
    [DistribSMul M A] [DistribMulAction N A] [SMulCommClass M N A] (c : M) : A →+[N] A 
goal: ∀ (x : A), (SMulCommClass.toDistribMulActionHom N A c) x = c • x

full_name: SMulCommClass.toDistribMulActionHom
code: /-- If `DistribMulAction` of `M` and `N` on `A` commute,
  then for each `c : M`, `(c • ·)` is an `N`-action additive homomorphism. -/
@[simps]
def _root_.SMulCommClass.toDistribMulActionHom {M} (N A : Type*) [Monoid N] [AddMonoid A]
    [DistribSMul M A] [DistribMulAction N A] [SMulCommClass M N A] (c : M) : A →+[N] A 
goal: A →+[N] A

full_name: DistribMulActionHom.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : A →ₑ+[φ] B) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: DistribMulActionHom.coe_fn_coe
code: @[norm_cast]
theorem coe_fn_coe (f : A →ₑ+[φ] B) : ⇑(f : A →+ B) = f 
goal: ⇑↑f = ⇑f

full_name: DistribMulActionHom.coe_fn_coe'
code: @[norm_cast]
theorem coe_fn_coe' (f : A →ₑ+[φ] B) : ⇑(f : A →ₑ[φ] B) = f 
goal: ⇑↑f = ⇑f

full_name: DistribMulActionHom.ext
code: @[ext]
theorem ext {f g : A →ₑ+[φ] B} : (∀ x, f x = g x) → f = g 
goal: (∀ (x : A), f x = g x) → f = g

full_name: DistribMulActionHom.ext_iff
code: theorem ext_iff {f g : A →ₑ+[φ] B} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : A), f x = g x

full_name: DistribMulActionHom.congr_fun
code: protected theorem congr_fun {f g : A →ₑ+[φ] B} (h : f = g) (x : A) : f x = g x 
goal: f x = g x

full_name: DistribMulActionHom.toMulActionHom_injective
code: theorem toMulActionHom_injective {f g : A →ₑ+[φ] B} (h : (f : A →ₑ[φ] B) = (g : A →ₑ[φ] B)) :
    f = g 
goal: f = g

full_name: DistribMulActionHom.toAddMonoidHom_injective
code: theorem toAddMonoidHom_injective {f g : A →ₑ+[φ] B} (h : (f : A →+ B) = (g : A →+ B)) : f = g 
goal: f = g

full_name: DistribMulActionHom.map_zero
code: protected theorem map_zero (f : A →ₑ+[φ] B) : f 0 = 0 
goal: f 0 = 0

full_name: DistribMulActionHom.map_add
code: protected theorem map_add (f : A →ₑ+[φ] B) (x y : A) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: DistribMulActionHom.map_neg
code: protected theorem map_neg (f : A' →ₑ+[φ] B') (x : A') : f (-x) = -f x 
goal: f (-x) = -f x

full_name: DistribMulActionHom.map_sub
code: protected theorem map_sub (f : A' →ₑ+[φ] B') (x y : A') : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: DistribMulActionHom.map_smulₑ
code: protected theorem map_smulₑ (f : A →ₑ+[φ] B) (m : M) (x : A) : f (m • x) = (φ m) • f x 
goal: f (m • x) = φ m • f x

full_name: DistribMulActionHom.id
code: /-- The identity map as an equivariant additive monoid homomorphism. -/
protected def id : A →+[M] A 
goal: A →+[M] A

full_name: DistribMulActionHom.id_apply
code: @[simp]
theorem id_apply (x : A) : DistribMulActionHom.id M x = x 
goal: (DistribMulActionHom.id M) x = x

full_name: DistribMulActionHom.instZero
code: instance : Zero (A →ₑ+[φ] B) 
goal: Zero (A →ₑ+[φ] B)

full_name: DistribMulActionHom.instOneId
code: instance : One (A →+[M] A) 
goal: One (A →+[M] A)

full_name: DistribMulActionHom.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : A →ₑ+[φ] B) = 0 
goal: ⇑0 = 0

full_name: DistribMulActionHom.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : A →+[M] A) = id 
goal: ⇑1 = id

full_name: DistribMulActionHom.zero_apply
code: theorem zero_apply (a : A) : (0 : A →ₑ+[φ] B) a = 0 
goal: 0 a = 0

full_name: DistribMulActionHom.one_apply
code: theorem one_apply (a : A) : (1 : A →+[M] A) a = a 
goal: 1 a = a

full_name: DistribMulActionHom.instInhabited
code: instance : Inhabited (A →ₑ+[φ] B) 
goal: Inhabited (A →ₑ+[φ] B)

full_name: DistribMulActionHom.comp
code: /-- Composition of two equivariant additive monoid homomorphisms. -/
def comp (g : B →ₑ+[ψ] C) (f : A →ₑ+[φ] B) [κ : MonoidHom.CompTriple φ ψ χ] :
    A →ₑ+[χ] C 
goal: A →ₑ+[χ] C

full_name: DistribMulActionHom.comp_apply
code: @[simp]
theorem comp_apply
    (g : B →ₑ+[ψ] C) (f : A →ₑ+[φ] B) [MonoidHom.CompTriple φ ψ χ] (x : A) : g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: DistribMulActionHom.id_comp
code: @[simp]
theorem id_comp (f : A →ₑ+[φ] B) : comp (DistribMulActionHom.id N) f = f 
goal: (DistribMulActionHom.id N).comp f = f

full_name: DistribMulActionHom.comp_id
code: @[simp]
theorem comp_id (f : A →ₑ+[φ] B) : f.comp (DistribMulActionHom.id M) = f 
goal: f.comp (DistribMulActionHom.id M) = f

full_name: DistribMulActionHom.comp_assoc
code: @[simp]
theorem comp_assoc {Q D : Type*} [Monoid Q] [AddMonoid D] [DistribMulAction Q D]
    {η : P →* Q} {θ : M →* Q} {ζ : N →* Q}
    (h : C →ₑ+[η] D) (g : B →ₑ+[ψ] C) (f : A →ₑ+[φ] B)
    [MonoidHom.CompTriple φ ψ χ] [MonoidHom.CompTriple χ η θ]
    [MonoidHom.CompTriple ψ η ζ] [MonoidHom.CompTriple φ ζ θ] :
    h.comp (g.comp f) = (h.comp g).comp f 
goal: h.comp (g.comp f) = (h.comp g).comp f

full_name: DistribMulActionHom.inverse_toFun
code: /-- The inverse of a bijective `DistribMulActionHom` is a `DistribMulActionHom`. -/
@[simps]
def inverse (f : A →+[M] B₁) (g : B₁ → A) (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : B₁ →+[M] A 
goal: ∀ (a : B₁), (f.inverse g h₁ h₂) a = g a

full_name: DistribMulActionHom.inverse
code: /-- The inverse of a bijective `DistribMulActionHom` is a `DistribMulActionHom`. -/
@[simps]
def inverse (f : A →+[M] B₁) (g : B₁ → A) (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : B₁ →+[M] A 
goal: B₁ →+[M] A

full_name: DistribMulActionHom.ext_ring
code: @[ext]
theorem ext_ring {f g : R →ₑ+[σ] N'} (h : f 1 = g 1) : f = g 
goal: f = g

full_name: DistribMulActionHom.ext_ring_iff
code: theorem ext_ring_iff {f g : R →ₑ+[σ] N'} : f = g ↔ f 1 = g 1 
goal: f = g ↔ f 1 = g 1

full_name: MulSemiringActionHom
code: /-- Equivariant ring homomorphisms. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure MulSemiringActionHom extends R →ₑ+[φ] S, R →+* S
goal: Type (max u_10 u_12)

full_name: «MulSemiringActionHomLocal≺»
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomLocal≺»)
  R " →ₑ+*[" φ:25 "] " S:0 => MulSemiringActionHom φ R S
goal: Lean.TrailingParserDescr

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_MulSemiringActionHomLocal≺_1»
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomLocal≺»)
  R " →ₑ+*[" φ:25 "] " S:0 => MulSemiringActionHom φ R S
goal: Lean.Macro

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulSemiringActionHom_1
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomLocal≺»)
  R " →ₑ+*[" φ:25 "] " S:0 => MulSemiringActionHom φ R S
goal: Lean.PrettyPrinter.Unexpander

full_name: «MulSemiringActionHomIdLocal≺»
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomIdLocal≺»)
  R " →+*[" M:25 "] " S:0 => MulSemiringActionHom (MonoidHom.id M) R S
goal: Lean.TrailingParserDescr

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Hom___macroRules_MulSemiringActionHomIdLocal≺_1»
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomIdLocal≺»)
  R " →+*[" M:25 "] " S:0 => MulSemiringActionHom (MonoidHom.id M) R S
goal: Lean.Macro

full_name: _aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulSemiringActionHom_2
code: @[inherit_doc]
notation:25 (name := «MulSemiringActionHomIdLocal≺»)
  R " →+*[" M:25 "] " S:0 => MulSemiringActionHom (MonoidHom.id M) R S
goal: Lean.PrettyPrinter.Unexpander

full_name: MulSemiringActionSemiHomClass
code: /-- `MulSemiringActionHomClass F φ R S` states that `F` is a type of morphisms preserving
the ring structure and equivariant with respect to `φ`.

You should extend this class when you extend `MulSemiringActionHom`. -/
class MulSemiringActionSemiHomClass (F : Type*)
    {M N : outParam Type*} [Monoid M] [Monoid N]
    (φ : outParam (M → N))
    (R S : outParam Type*) [Semiring R] [Semiring S]
    [DistribMulAction M R] [DistribMulAction N S] [FunLike F R S]
    extends DistribMulActionSemiHomClass F φ R S, RingHomClass F R S : Prop
goal: Prop

full_name: MulSemiringActionHomClass
code: /-- `MulSemiringActionHomClass F M R S` states that `F` is a type of morphisms preserving
the ring structure and equivariant with respect to a `DistribMulAction`of `M` on `R` and `S` .
 -/
abbrev MulSemiringActionHomClass
    (F : Type*)
    {M : outParam Type*} [Monoid M]
    (R S : outParam Type*) [Semiring R] [Semiring S]
    [DistribMulAction M R] [DistribMulAction M S] [FunLike F R S] 
goal: Prop

full_name: MulSemiringActionHom.instFunLike
code: instance : FunLike (R →ₑ+*[φ] S) R S 
goal: FunLike (R →ₑ+*[φ] S) R S

full_name: MulSemiringActionHom.instMulSemiringActionSemiHomClassCoeMonoidHom
code: instance : MulSemiringActionSemiHomClass (R →ₑ+*[φ] S) φ R S 
goal: MulSemiringActionSemiHomClass (R →ₑ+*[φ] S) (⇑φ) R S

full_name: MulSemiringActionHomClass.toMulSemiringActionHom
code: /-- Turn an element of a type `F` satisfying `MulSemiringActionHomClass F M R S` into an actual
`MulSemiringActionHom`. This is declared as the default coercion from `F` to
`MulSemiringActionHom M X Y`. -/
@[coe]
def _root_.MulSemiringActionHomClass.toMulSemiringActionHom
    [MulSemiringActionSemiHomClass F φ R S]
    (f : F) : R →ₑ+*[φ] S 
goal: R →ₑ+*[φ] S

full_name: MulSemiringActionHom.instCoeTCOfMulSemiringActionSemiHomClassCoeMonoidHom
code: /-- Any type satisfying `MulSemiringActionHomClass` can be cast into `MulSemiringActionHom` via
  `MulSemiringActionHomClass.toMulSemiringActionHom`. -/
instance [MulSemiringActionSemiHomClass F φ R S] :
    CoeTC F (R →ₑ+*[φ] S) 
goal: CoeTC F (R →ₑ+*[φ] S)

full_name: MulSemiringActionHom.coe_fn_coe
code: @[norm_cast]
theorem coe_fn_coe (f : R →ₑ+*[φ] S) : ⇑(f : R →+* S) = f 
goal: ⇑↑f = ⇑f

full_name: MulSemiringActionHom.coe_fn_coe'
code: @[norm_cast]
theorem coe_fn_coe' (f : R →ₑ+*[φ] S) : ⇑(f : R →ₑ+[φ] S) = f 
goal: ⇑↑f = ⇑f

full_name: MulSemiringActionHom.ext
code: @[ext]
theorem ext {f g : R →ₑ+*[φ] S} : (∀ x, f x = g x) → f = g 
goal: (∀ (x : R), f x = g x) → f = g

full_name: MulSemiringActionHom.ext_iff
code: theorem ext_iff {f g : R →ₑ+*[φ] S} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : R), f x = g x

full_name: MulSemiringActionHom.map_zero
code: protected theorem map_zero (f : R →ₑ+*[φ] S) : f 0 = 0 
goal: f 0 = 0

full_name: MulSemiringActionHom.map_add
code: protected theorem map_add (f : R →ₑ+*[φ] S) (x y : R) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: MulSemiringActionHom.map_neg
code: protected theorem map_neg (f : R' →ₑ+*[φ] S') (x : R') : f (-x) = -f x 
goal: f (-x) = -f x

full_name: MulSemiringActionHom.map_sub
code: protected theorem map_sub (f : R' →ₑ+*[φ] S') (x y : R') : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: MulSemiringActionHom.map_one
code: protected theorem map_one (f : R →ₑ+*[φ] S) : f 1 = 1 
goal: f 1 = 1

full_name: MulSemiringActionHom.map_mul
code: protected theorem map_mul (f : R →ₑ+*[φ] S) (x y : R) : f (x * y) = f x * f y 
goal: f (x * y) = f x * f y

full_name: MulSemiringActionHom.map_smulₛₗ
code: protected theorem map_smulₛₗ (f : R →ₑ+*[φ] S) (m : M) (x : R) : f (m • x) = φ m • f x 
goal: f (m • x) = φ m • f x

full_name: MulSemiringActionHom.map_smul
code: protected theorem map_smul [MulSemiringAction M S] (f : R →+*[M] S) (m : M) (x : R) :
    f (m • x) = m • f x 
goal: f (m • x) = m • f x

full_name: MulSemiringActionHom.id
code: /-- The identity map as an equivariant ring homomorphism. -/
protected def id : R →+*[M] R 
goal: R →+*[M] R

full_name: MulSemiringActionHom.id_apply
code: @[simp]
theorem id_apply (x : R) : MulSemiringActionHom.id M x = x 
goal: (MulSemiringActionHom.id M) x = x

full_name: MulSemiringActionHom.comp
code: /-- Composition of two equivariant additive ring homomorphisms. -/
def comp (g : S →ₑ+*[ψ] T) (f : R →ₑ+*[φ] S) [κ : MonoidHom.CompTriple φ ψ χ] : R →ₑ+*[χ] T 
goal: R →ₑ+*[χ] T

full_name: MulSemiringActionHom.comp_apply
code: @[simp]
theorem comp_apply (g : S →ₑ+*[ψ] T) (f : R →ₑ+*[φ] S) [MonoidHom.CompTriple φ ψ χ] (x : R) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: MulSemiringActionHom.id_comp
code: @[simp]
theorem id_comp (f : R →ₑ+*[φ] S) : (MulSemiringActionHom.id N).comp f = f 
goal: (MulSemiringActionHom.id N).comp f = f

full_name: MulSemiringActionHom.comp_id
code: @[simp]
theorem comp_id (f : R →ₑ+*[φ] S) : f.comp (MulSemiringActionHom.id M) = f 
goal: f.comp (MulSemiringActionHom.id M) = f

full_name: MulSemiringActionHom.inverse'
code: /-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse' (f : R →ₑ+*[φ] S) (g : S → R) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S →ₑ+*[φ'] R 
goal: S →ₑ+*[φ'] R

full_name: MulSemiringActionHom.inverse'_toFun
code: /-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse' (f : R →ₑ+*[φ] S) (g : S → R) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S →ₑ+*[φ'] R 
goal: ∀ (a : S), (f.inverse' g k h₁ h₂) a = g a

full_name: MulSemiringActionHom.inverse_toFun
code: /-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse {S₁ : Type*} [Semiring S₁] [MulSemiringAction M S₁]
    (f : R →+*[M] S₁) (g : S₁ → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S₁ →+*[M] R 
goal: ∀ (a : S₁), (f.inverse g h₁ h₂) a = g a

full_name: MulSemiringActionHom.inverse
code: /-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse {S₁ : Type*} [Semiring S₁] [MulSemiringAction M S₁]
    (f : R →+*[M] S₁) (g : S₁ → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S₁ →+*[M] R 
goal: S₁ →+*[M] R