File: Mathlib/Algebra/Algebra/Hom.lean

full_name: AlgHom.commutes'
code: /-- Defining the homomorphism in the category R-Alg. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): linter not ported yet
structure AlgHom (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends RingHom A B where
  commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
goal: (↑↑self.toRingHom).toFun ((algebraMap R A) r) = (algebraMap R B) r

full_name: AlgHom
code: /-- Defining the homomorphism in the category R-Alg. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): linter not ported yet
structure AlgHom (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends RingHom A B where
  commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
goal: Type (max v w)

full_name: «_aux_Mathlib_Algebra_Algebra_Hom___macroRules_term_→ₐ__1»
code: @[inherit_doc AlgHom]
infixr:25 " →ₐ " => AlgHom _
goal: Lean.Macro

full_name: «_aux_Mathlib_Algebra_Algebra_Hom___macroRules_term_→ₐ[_]__1»
code: @[inherit_doc]
notation:25 A " →ₐ[" R "] " B => AlgHom R A B
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Algebra_Hom___unexpand_AlgHom_1
code: @[inherit_doc]
notation:25 A " →ₐ[" R "] " B => AlgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgHomClass.commutes
code: /-- `AlgHomClass F R A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B`.  -/
class AlgHomClass (F : Type*) (R A B : outParam Type*)
  [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
  [FunLike F A B] extends RingHomClass F A B : Prop where
  commutes : ∀ (f : F) (r : R), f (algebraMap R A r) = algebraMap R B r
goal: f ((algebraMap R A) r) = (algebraMap R B) r

full_name: AlgHomClass
code: /-- `AlgHomClass F R A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B`.  -/
class AlgHomClass (F : Type*) (R A B : outParam Type*)
  [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
  [FunLike F A B] extends RingHomClass F A B : Prop where
  commutes : ∀ (f : F) (r : R), f (algebraMap R A r) = algebraMap R B r
goal: Prop

full_name: AlgHomClass.linearMapClass
code: instance (priority := 100) linearMapClass [AlgHomClass F R A B] : LinearMapClass F R A B 
goal: LinearMapClass F R A B

full_name: AlgHomClass.toAlgHom
code: /-- Turn an element of a type `F` satisfying `AlgHomClass F α β` into an actual
`AlgHom`. This is declared as the default coercion from `F` to `α →+* β`. -/
@[coe]
def toAlgHom {F : Type*} [FunLike F A B] [AlgHomClass F R A B] (f : F) : A →ₐ[R] B 
goal: A →ₐ[R] B

full_name: AlgHomClass.coeTC
code: instance coeTC {F : Type*} [FunLike F A B] [AlgHomClass F R A B] : CoeTC F (A →ₐ[R] B) 
goal: CoeTC F (A →ₐ[R] B)

full_name: AlgHom.funLike
code: instance funLike : FunLike (A →ₐ[R] B) A B 
goal: FunLike (A →ₐ[R] B) A B

full_name: AlgHom.algHomClass
code: instance algHomClass : AlgHomClass (A →ₐ[R] B) R A B 
goal: AlgHomClass (A →ₐ[R] B) R A B

full_name: AlgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply {R : Type u} {α : Type v} {β : Type w} [CommSemiring R]
    [Semiring α] [Semiring β] [Algebra R α] [Algebra R β] (f : α →ₐ[R] β) : α → β 
goal: α → β

full_name: AlgHom.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [AlgHomClass F R A B] (f : F) :
    ⇑(f : A →ₐ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: AlgHom.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : A →ₐ[R] B) : f.toFun = f 
goal: (↑↑f.toRingHom).toFun = ⇑f

full_name: AlgHom.toMonoidHom'
code: @[coe]
def toMonoidHom' (f : A →ₐ[R] B) : A →* B 
goal: A →* B

full_name: AlgHom.coeOutMonoidHom
code: instance coeOutMonoidHom : CoeOut (A →ₐ[R] B) (A →* B) 
goal: CoeOut (A →ₐ[R] B) (A →* B)

full_name: AlgHom.toAddMonoidHom'
code: @[coe]
def toAddMonoidHom' (f : A →ₐ[R] B) : A →+ B 
goal: A →+ B

full_name: AlgHom.coeOutAddMonoidHom
code: instance coeOutAddMonoidHom : CoeOut (A →ₐ[R] B) (A →+ B) 
goal: CoeOut (A →ₐ[R] B) (A →+ B)

full_name: AlgHom.coe_mk
code: @[simp]
theorem coe_mk {f : A →+* B} (h) : ((⟨f, h⟩ : A →ₐ[R] B) : A → B) = f 
goal: ⇑{ toRingHom := f, commutes' := h } = ⇑f

full_name: AlgHom.coe_mks
code: @[norm_cast]
theorem coe_mks {f : A → B} (h₁ h₂ h₃ h₄ h₅) : ⇑(⟨⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩, h₅⟩ : A →ₐ[R] B) = f 
goal: ⇑{ toFun := f, map_one' := h₁, map_mul' := h₂, map_zero' := h₃, map_add' := h₄, commutes' := h₅ } = f

full_name: AlgHom.coe_ringHom_mk
code: @[simp, norm_cast]
theorem coe_ringHom_mk {f : A →+* B} (h) : ((⟨f, h⟩ : A →ₐ[R] B) : A →+* B) = f 
goal: ↑{ toRingHom := f, commutes' := h } = f

full_name: AlgHom.toRingHom_eq_coe
code: @[simp]
theorem toRingHom_eq_coe (f : A →ₐ[R] B) : f.toRingHom = f 
goal: f.toRingHom = ↑f

full_name: AlgHom.coe_toRingHom
code: @[simp, norm_cast]
theorem coe_toRingHom (f : A →ₐ[R] B) : ⇑(f : A →+* B) = f 
goal: ⇑↑f = ⇑f

full_name: AlgHom.coe_toMonoidHom
code: @[simp, norm_cast]
theorem coe_toMonoidHom (f : A →ₐ[R] B) : ⇑(f : A →* B) = f 
goal: ⇑↑f = ⇑f

full_name: AlgHom.coe_toAddMonoidHom
code: @[simp, norm_cast]
theorem coe_toAddMonoidHom (f : A →ₐ[R] B) : ⇑(f : A →+ B) = f 
goal: ⇑↑f = ⇑f

full_name: AlgHom.coe_fn_injective
code: theorem coe_fn_injective : @Function.Injective (A →ₐ[R] B) (A → B) (↑) 
goal: Function.Injective DFunLike.coe

full_name: AlgHom.coe_fn_inj
code: theorem coe_fn_inj {φ₁ φ₂ : A →ₐ[R] B} : (φ₁ : A → B) = φ₂ ↔ φ₁ = φ₂ 
goal: ⇑φ₁ = ⇑φ₂ ↔ φ₁ = φ₂

full_name: AlgHom.coe_ringHom_injective
code: theorem coe_ringHom_injective : Function.Injective ((↑) : (A →ₐ[R] B) → A →+* B) 
goal: Function.Injective RingHomClass.toRingHom

full_name: AlgHom.coe_monoidHom_injective
code: theorem coe_monoidHom_injective : Function.Injective ((↑) : (A →ₐ[R] B) → A →* B) 
goal: Function.Injective MonoidHomClass.toMonoidHom

full_name: AlgHom.coe_addMonoidHom_injective
code: theorem coe_addMonoidHom_injective : Function.Injective ((↑) : (A →ₐ[R] B) → A →+ B) 
goal: Function.Injective AddMonoidHomClass.toAddMonoidHom

full_name: AlgHom.congr_fun
code: protected theorem congr_fun {φ₁ φ₂ : A →ₐ[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x 
goal: φ₁ x = φ₂ x

full_name: AlgHom.congr_arg
code: protected theorem congr_arg (φ : A →ₐ[R] B) {x y : A} (h : x = y) : φ x = φ y 
goal: φ x = φ y

full_name: AlgHom.ext
code: @[ext]
theorem ext {φ₁ φ₂ : A →ₐ[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂ 
goal: φ₁ = φ₂

full_name: AlgHom.ext_iff
code: theorem ext_iff {φ₁ φ₂ : A →ₐ[R] B} : φ₁ = φ₂ ↔ ∀ x, φ₁ x = φ₂ x 
goal: φ₁ = φ₂ ↔ ∀ (x : A), φ₁ x = φ₂ x

full_name: AlgHom.mk_coe
code: @[simp]
theorem mk_coe {f : A →ₐ[R] B} (h₁ h₂ h₃ h₄ h₅) : (⟨⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩, h₅⟩ : A →ₐ[R] B) = f 
goal: { toFun := ⇑f, map_one' := h₁, map_mul' := h₂, map_zero' := h₃, map_add' := h₄, commutes' := h₅ } = f

full_name: AlgHom.commutes
code: @[simp]
theorem commutes (r : R) : φ (algebraMap R A r) = algebraMap R B r 
goal: φ ((algebraMap R A) r) = (algebraMap R B) r

full_name: AlgHom.comp_algebraMap
code: theorem comp_algebraMap : (φ : A →+* B).comp (algebraMap R A) = algebraMap R B 
goal: (↑φ).comp (algebraMap R A) = algebraMap R B

full_name: AlgHom.map_add
code: @[deprecated map_add (since := "2024-06-26")]
protected theorem map_add (r s : A) : φ (r + s) = φ r + φ s 
goal: φ (r + s) = φ r + φ s

full_name: AlgHom.map_zero
code: @[deprecated map_zero (since := "2024-06-26")]
protected theorem map_zero : φ 0 = 0 
goal: φ 0 = 0

full_name: AlgHom.map_mul
code: @[deprecated map_mul (since := "2024-06-26")]
protected theorem map_mul (x y) : φ (x * y) = φ x * φ y 
goal: φ (x * y) = φ x * φ y

full_name: AlgHom.map_one
code: @[deprecated map_one (since := "2024-06-26")]
protected theorem map_one : φ 1 = 1 
goal: φ 1 = 1

full_name: AlgHom.map_pow
code: @[deprecated map_pow (since := "2024-06-26")]
protected theorem map_pow (x : A) (n : ℕ) : φ (x ^ n) = φ x ^ n 
goal: φ (x ^ n) = φ x ^ n

full_name: AlgHom.map_smul
code: @[deprecated map_smul (since := "2024-06-26")]
protected theorem map_smul (r : R) (x : A) : φ (r • x) = r • φ x 
goal: φ (r • x) = r • φ x

full_name: AlgHom.map_sum
code: @[deprecated map_sum (since := "2024-06-26")]
protected theorem map_sum {ι : Type*} (f : ι → A) (s : Finset ι) :
    φ (∑ x ∈ s, f x) = ∑ x ∈ s, φ (f x) 
goal: φ (∑ x ∈ s, f x) = ∑ x ∈ s, φ (f x)

full_name: AlgHom.map_finsupp_sum
code: @[deprecated map_finsupp_sum (since := "2024-06-26")]
protected theorem map_finsupp_sum {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A) :
    φ (f.sum g) = f.sum fun i a => φ (g i a) 
goal: φ (f.sum g) = f.sum fun i a => φ (g i a)

full_name: AlgHom.mk'
code: /-- If a `RingHom` is `R`-linear, then it is an `AlgHom`. -/
def mk' (f : A →+* B) (h : ∀ (c : R) (x), f (c • x) = c • f x) : A →ₐ[R] B 
goal: A →ₐ[R] B

full_name: AlgHom.coe_mk'
code: @[simp]
theorem coe_mk' (f : A →+* B) (h : ∀ (c : R) (x), f (c • x) = c • f x) : ⇑(mk' f h) = f 
goal: ⇑(AlgHom.mk' f h) = ⇑f

full_name: AlgHom.id
code: /-- Identity map as an `AlgHom`. -/
protected def id : A →ₐ[R] A 
goal: A →ₐ[R] A

full_name: AlgHom.coe_id
code: @[simp]
theorem coe_id : ⇑(AlgHom.id R A) = id 
goal: ⇑(AlgHom.id R A) = id

full_name: AlgHom.id_toRingHom
code: @[simp]
theorem id_toRingHom : (AlgHom.id R A : A →+* A) = RingHom.id _ 
goal: ↑(AlgHom.id R A) = RingHom.id A

full_name: AlgHom.id_apply
code: theorem id_apply (p : A) : AlgHom.id R A p = p 
goal: (AlgHom.id R A) p = p

full_name: AlgHom.comp
code: /-- Composition of algebra homeomorphisms. -/
def comp (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) : A →ₐ[R] C 
goal: A →ₐ[R] C

full_name: AlgHom.coe_comp
code: @[simp]
theorem coe_comp (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) : ⇑(φ₁.comp φ₂) = φ₁ ∘ φ₂ 
goal: ⇑(φ₁.comp φ₂) = ⇑φ₁ ∘ ⇑φ₂

full_name: AlgHom.comp_apply
code: theorem comp_apply (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) (p : A) : φ₁.comp φ₂ p = φ₁ (φ₂ p) 
goal: (φ₁.comp φ₂) p = φ₁ (φ₂ p)

full_name: AlgHom.comp_toRingHom
code: theorem comp_toRingHom (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) :
    (φ₁.comp φ₂ : A →+* C) = (φ₁ : B →+* C).comp ↑φ₂ 
goal: ↑(φ₁.comp φ₂) = (↑φ₁).comp ↑φ₂

full_name: AlgHom.comp_id
code: @[simp]
theorem comp_id : φ.comp (AlgHom.id R A) = φ 
goal: φ.comp (AlgHom.id R A) = φ

full_name: AlgHom.id_comp
code: @[simp]
theorem id_comp : (AlgHom.id R B).comp φ = φ 
goal: (AlgHom.id R B).comp φ = φ

full_name: AlgHom.comp_assoc
code: theorem comp_assoc (φ₁ : C →ₐ[R] D) (φ₂ : B →ₐ[R] C) (φ₃ : A →ₐ[R] B) :
    (φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃) 
goal: (φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃)

full_name: AlgHom.toLinearMap
code: /-- R-Alg ⥤ R-Mod -/
def toLinearMap : A →ₗ[R] B 
goal: A →ₗ[R] B

full_name: AlgHom.toLinearMap_apply
code: @[simp]
theorem toLinearMap_apply (p : A) : φ.toLinearMap p = φ p 
goal: φ.toLinearMap p = φ p

full_name: AlgHom.toLinearMap_injective
code: theorem toLinearMap_injective :
    Function.Injective (toLinearMap : _ → A →ₗ[R] B) 
goal: Function.Injective AlgHom.toLinearMap

full_name: AlgHom.comp_toLinearMap
code: @[simp]
theorem comp_toLinearMap (f : A →ₐ[R] B) (g : B →ₐ[R] C) :
    (g.comp f).toLinearMap = g.toLinearMap.comp f.toLinearMap 
goal: (g.comp f).toLinearMap = g.toLinearMap ∘ₗ f.toLinearMap

full_name: AlgHom.toLinearMap_id
code: @[simp]
theorem toLinearMap_id : toLinearMap (AlgHom.id R A) = LinearMap.id 
goal: (AlgHom.id R A).toLinearMap = LinearMap.id

full_name: AlgHom.ofLinearMap_apply
code: /-- Promote a `LinearMap` to an `AlgHom` by supplying proofs about the behavior on `1` and `*`. -/
@[simps]
def ofLinearMap (f : A →ₗ[R] B) (map_one : f 1 = 1) (map_mul : ∀ x y, f (x * y) = f x * f y) :
    A →ₐ[R] B 
goal: (AlgHom.ofLinearMap f map_one map_mul) a = f a

full_name: AlgHom.ofLinearMap
code: /-- Promote a `LinearMap` to an `AlgHom` by supplying proofs about the behavior on `1` and `*`. -/
@[simps]
def ofLinearMap (f : A →ₗ[R] B) (map_one : f 1 = 1) (map_mul : ∀ x y, f (x * y) = f x * f y) :
    A →ₐ[R] B 
goal: A →ₐ[R] B

full_name: AlgHom.ofLinearMap_toLinearMap
code: @[simp]
theorem ofLinearMap_toLinearMap (map_one) (map_mul) :
    ofLinearMap φ.toLinearMap map_one map_mul = φ 
goal: AlgHom.ofLinearMap φ.toLinearMap map_one map_mul = φ

full_name: AlgHom.toLinearMap_ofLinearMap
code: @[simp]
theorem toLinearMap_ofLinearMap (f : A →ₗ[R] B) (map_one) (map_mul) :
    toLinearMap (ofLinearMap f map_one map_mul) = f 
goal: (AlgHom.ofLinearMap f map_one map_mul).toLinearMap = f

full_name: AlgHom.ofLinearMap_id
code: @[simp]
theorem ofLinearMap_id (map_one) (map_mul) :
    ofLinearMap LinearMap.id map_one map_mul = AlgHom.id R A 
goal: AlgHom.ofLinearMap LinearMap.id map_one map_mul = AlgHom.id R A

full_name: AlgHom.map_smul_of_tower
code: theorem map_smul_of_tower {R'} [SMul R' A] [SMul R' B] [LinearMap.CompatibleSMul A B R' R] (r : R')
    (x : A) : φ (r • x) = r • φ x 
goal: φ (r • x) = r • φ x

full_name: AlgHom.map_list_prod
code: @[deprecated map_list_prod (since := "2024-06-26")]
protected theorem map_list_prod (s : List A) : φ s.prod = (s.map φ).prod 
goal: φ s.prod = (List.map (⇑φ) s).prod

full_name: AlgHom.End_toOne_one
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐ[R] A) 
goal: 1 = AlgHom.id R A

full_name: AlgHom.End_toSemigroup_toMul_mul
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐ[R] A) 
goal: φ₁ * φ₂ = φ₁.comp φ₂

full_name: AlgHom.End
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐ[R] A) 
goal: Monoid (A →ₐ[R] A)

full_name: AlgHom.one_apply
code: @[simp]
theorem one_apply (x : A) : (1 : A →ₐ[R] A) x = x 
goal: 1 x = x

full_name: AlgHom.mul_apply
code: @[simp]
theorem mul_apply (φ ψ : A →ₐ[R] A) (x : A) : (φ * ψ) x = φ (ψ x) 
goal: (φ * ψ) x = φ (ψ x)

full_name: AlgHom.algebraMap_eq_apply
code: theorem algebraMap_eq_apply (f : A →ₐ[R] B) {y : R} {x : A} (h : algebraMap R A y = x) :
    algebraMap R B y = f x 
goal: (algebraMap R B) y = f x

full_name: AlgHom.map_multiset_prod
code: @[deprecated map_multiset_prod (since := "2024-06-26")]
protected theorem map_multiset_prod (s : Multiset A) : φ s.prod = (s.map φ).prod 
goal: φ s.prod = (Multiset.map (⇑φ) s).prod

full_name: AlgHom.map_prod
code: @[deprecated map_prod (since := "2024-06-26")]
protected theorem map_prod {ι : Type*} (f : ι → A) (s : Finset ι) :
    φ (∏ x ∈ s, f x) = ∏ x ∈ s, φ (f x) 
goal: φ (∏ x ∈ s, f x) = ∏ x ∈ s, φ (f x)

full_name: AlgHom.map_finsupp_prod
code: @[deprecated map_finsupp_prod (since := "2024-06-26")]
protected theorem map_finsupp_prod {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A) :
    φ (f.prod g) = f.prod fun i a => φ (g i a) 
goal: φ (f.prod g) = f.prod fun i a => φ (g i a)

full_name: AlgHom.map_neg
code: @[deprecated map_neg (since := "2024-06-26")]
protected theorem map_neg (x) : φ (-x) = -φ x 
goal: φ (-x) = -φ x

full_name: AlgHom.map_sub
code: @[deprecated map_sub (since := "2024-06-26")]
protected theorem map_sub (x y) : φ (x - y) = φ x - φ y 
goal: φ (x - y) = φ x - φ y

full_name: RingHom.toNatAlgHom
code: /-- Reinterpret a `RingHom` as an `ℕ`-algebra homomorphism. -/
def toNatAlgHom [Semiring R] [Semiring S] (f : R →+* S) : R →ₐ[ℕ] S 
goal: R →ₐ[ℕ] S

full_name: RingHom.toIntAlgHom
code: /-- Reinterpret a `RingHom` as a `ℤ`-algebra homomorphism. -/
def toIntAlgHom [Ring R] [Ring S] [Algebra ℤ R] [Algebra ℤ S] (f : R →+* S) : R →ₐ[ℤ] S 
goal: R →ₐ[ℤ] S

full_name: RingHom.toIntAlgHom_injective
code: lemma toIntAlgHom_injective [Ring R] [Ring S] [Algebra ℤ R] [Algebra ℤ S] :
    Function.Injective (RingHom.toIntAlgHom : (R →+* S) → _) 
goal: Function.Injective RingHom.toIntAlgHom

full_name: Algebra.ofId
code: /-- `AlgebraMap` as an `AlgHom`. -/
def ofId : R →ₐ[R] A 
goal: R →ₐ[R] A

full_name: Algebra.ofId_apply
code: theorem ofId_apply (r) : ofId R A r = algebraMap R A r 
goal: (Algebra.ofId R A) r = (algebraMap R A) r

full_name: Algebra.subsingleton_id
code: /-- This is a special case of a more general instance that we define in a later file. -/
instance subsingleton_id : Subsingleton (R →ₐ[R] A) 
goal: Subsingleton (R →ₐ[R] A)

full_name: Algebra.ext_id
code: /-- This ext lemma closes trivial subgoals create when chaining heterobasic ext lemmas. -/
@[ext high]
theorem ext_id (f g : R →ₐ[R] A) : f = g 
goal: f = g

full_name: Algebra.instMulDistribMulActionAlgHomUnits
code: instance : MulDistribMulAction (A →ₐ[R] A) Aˣ 
goal: MulDistribMulAction (A →ₐ[R] A) Aˣ

full_name: Algebra.smul_units_def
code: @[simp]
theorem smul_units_def (f : A →ₐ[R] A) (x : Aˣ) :
    f • x = Units.map (f : A →* A) x 
goal: f • x = (Units.map ↑f) x

full_name: Algebra.algebraMapSubmonoid_map_eq
code: lemma algebraMapSubmonoid_map_eq (f : A →ₐ[R] B) :
    (algebraMapSubmonoid A M).map f = algebraMapSubmonoid B M 
goal: Submonoid.map f (Algebra.algebraMapSubmonoid A M) = Algebra.algebraMapSubmonoid B M

full_name: Algebra.algebraMapSubmonoid_le_comap
code: lemma algebraMapSubmonoid_le_comap (f : A →ₐ[R] B) :
    algebraMapSubmonoid A M ≤ (algebraMapSubmonoid B M).comap f.toRingHom 
goal: Algebra.algebraMapSubmonoid A M ≤ Submonoid.comap f.toRingHom (Algebra.algebraMapSubmonoid B M)

full_name: MulSemiringAction.toAlgHom_apply
code: /-- Each element of the monoid defines an algebra homomorphism.

This is a stronger version of `MulSemiringAction.toRingHom` and
`DistribMulAction.toLinearMap`. -/
@[simps]
def toAlgHom (m : M) : A →ₐ[R] A 
goal: (MulSemiringAction.toAlgHom R A m) a = m • a

full_name: MulSemiringAction.toAlgHom
code: /-- Each element of the monoid defines an algebra homomorphism.

This is a stronger version of `MulSemiringAction.toRingHom` and
`DistribMulAction.toLinearMap`. -/
@[simps]
def toAlgHom (m : M) : A →ₐ[R] A 
goal: A →ₐ[R] A

full_name: MulSemiringAction.toAlgHom_injective
code: theorem toAlgHom_injective [FaithfulSMul M A] :
    Function.Injective (MulSemiringAction.toAlgHom R A : M → A →ₐ[R] A) 
goal: Function.Injective (MulSemiringAction.toAlgHom R A)