File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

full_name: NonUnitalAlgHom
code: /-- A morphism respecting addition, multiplication, and scalar multiplication. When these arise from
algebra structures, this is the same as a not-necessarily-unital morphism of algebras. -/
structure NonUnitalAlgHom [Monoid R] [Monoid S] (φ : R →* S) (A : Type v) (B : Type w)
    [NonUnitalNonAssocSemiring A] [DistribMulAction R A]
    [NonUnitalNonAssocSemiring B] [DistribMulAction S B] extends A →ₑ+[φ] B, A →ₙ* B
goal: Type (max v w)

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

full_name: _aux_Mathlib_Algebra_Algebra_NonUnitalHom___unexpand_NonUnitalAlgHom_1
code: @[inherit_doc]
notation:25 A " →ₛₙₐ[" φ "] " B => NonUnitalAlgHom φ A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Algebra_NonUnitalHom___macroRules_term_→ₛₙₐ[_]__1»
code: @[inherit_doc]
notation:25 A " →ₛₙₐ[" φ "] " B => NonUnitalAlgHom φ A B
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Algebra_NonUnitalHom___unexpand_NonUnitalAlgHom_2
code: @[inherit_doc]
notation:25 A " →ₙₐ[" R "] " B => NonUnitalAlgHom (MonoidHom.id R) A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Algebra_NonUnitalHom___macroRules_term_→ₙₐ[_]__1»
code: @[inherit_doc]
notation:25 A " →ₙₐ[" R "] " B => NonUnitalAlgHom (MonoidHom.id R) A B
goal: Lean.Macro

full_name: NonUnitalAlgSemiHomClass
code: /-- `NonUnitalAlgSemiHomClass F φ A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B` which are equivariant with respect to `φ`.  -/
class NonUnitalAlgSemiHomClass (F : Type*) {R S : outParam Type*} [Monoid R] [Monoid S]
    (φ : outParam (R →* S)) (A B : outParam Type*)
    [NonUnitalNonAssocSemiring A] [NonUnitalNonAssocSemiring B]
    [DistribMulAction R A] [DistribMulAction S B] [FunLike F A B]
    extends DistribMulActionSemiHomClass F φ A B, MulHomClass F A B : Prop
goal: Prop

full_name: NonUnitalAlgHomClass
code: /-- `NonUnitalAlgHomClass F R A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B` which are `R`-linear.

  This is an abbreviation to `NonUnitalAlgSemiHomClass F (MonoidHom.id R) A B` -/
abbrev NonUnitalAlgHomClass (F : Type*) (R A B : outParam Type*)
    [Monoid R] [NonUnitalNonAssocSemiring A] [NonUnitalNonAssocSemiring B]
    [DistribMulAction R A] [DistribMulAction R B] [FunLike F A B] 
goal: Prop

full_name: NonUnitalAlgHomClass.toNonUnitalRingHomClass
code: instance (priority := 100) toNonUnitalRingHomClass
  {F R S A B : Type*} {_ : Monoid R} {_ : Monoid S} {φ : outParam (R →* S)}
    {_ : NonUnitalNonAssocSemiring A} [DistribMulAction R A]
    {_ : NonUnitalNonAssocSemiring B} [DistribMulAction S B] [FunLike F A B]
    [NonUnitalAlgSemiHomClass F φ A B] : NonUnitalRingHomClass F A B 
goal: ∀ {x : Monoid R} {x_1 : Monoid S} {φ : outParam (R →* S)} {x_2 : NonUnitalNonAssocSemiring A}
  [inst : DistribMulAction R A] {x_3 : NonUnitalNonAssocSemiring B} [inst_1 : DistribMulAction S B]
  [inst_2 : FunLike F A B] [inst : NonUnitalAlgSemiHomClass F φ A B], NonUnitalRingHomClass F A B

full_name: NonUnitalAlgHomClass.instSemilinearMapClassOfNonUnitalAlgSemiHomClassToMonoidHomRingHom
code: instance (priority := 100) {F R S A B : Type*}
    {_ : Semiring R} {_ : Semiring S} {φ : R →+* S}
    {_ : NonUnitalSemiring A} {_ : NonUnitalSemiring B} [Module R A] [Module S B] [FunLike F A B]
    [NonUnitalAlgSemiHomClass (R := R) (S := S) F φ A B] :
    SemilinearMapClass F φ A B 
goal: ∀ {x : Semiring R} {x_1 : Semiring S} {φ : R →+* S} {x_2 : NonUnitalSemiring A} {x_3 : NonUnitalSemiring B}
  [inst : Module R A] [inst_1 : Module S B] [inst_2 : FunLike F A B] [inst_3 : NonUnitalAlgSemiHomClass F (↑φ) A B],
  SemilinearMapClass F φ A B

full_name: NonUnitalAlgHomClass.instLinearMapClass
code: instance (priority := 100) {F : Type*} [FunLike F A B] [Module R B] [NonUnitalAlgHomClass F R A B] :
    LinearMapClass F R A B 
goal: LinearMapClass F R A B

full_name: NonUnitalAlgHomClass.toNonUnitalAlgSemiHom
code: /-- Turn an element of a type `F` satisfying `NonUnitalAlgSemiHomClass F φ A B` into an actual
`NonUnitalAlgHom`. This is declared as the default coercion from `F` to `A →ₛₙₐ[φ] B`. -/
@[coe]
def toNonUnitalAlgSemiHom {F R S : Type*} [Monoid R] [Monoid S] {φ : R →* S} {A B : Type*}
    [NonUnitalNonAssocSemiring A] [DistribMulAction R A]
    [NonUnitalNonAssocSemiring B] [DistribMulAction S B] [FunLike F A B]
    [NonUnitalAlgSemiHomClass F φ A B] (f : F) : A →ₛₙₐ[φ] B 
goal: A →ₛₙₐ[φ] B

full_name: NonUnitalAlgHomClass.instCoeTCNonUnitalAlgHomOfNonUnitalAlgSemiHomClass
code: instance {F R S A B : Type*} [Monoid R] [Monoid S] {φ : R →* S}
    [NonUnitalNonAssocSemiring A] [DistribMulAction R A]
    [NonUnitalNonAssocSemiring B] [DistribMulAction S B] [FunLike F A B]
    [NonUnitalAlgSemiHomClass F φ A B] :
      CoeTC F (A →ₛₙₐ[φ] B) 
goal: CoeTC F (A →ₛₙₐ[φ] B)

full_name: NonUnitalAlgHomClass.toNonUnitalAlgHom
code: /-- Turn an element of a type `F` satisfying `NonUnitalAlgHomClass F R A B` into an actual
@[coe]
`NonUnitalAlgHom`. This is declared as the default coercion from `F` to `A →ₛₙₐ[R] B`. -/
def toNonUnitalAlgHom {F R : Type*} [Monoid R] {A B : Type*}
    [NonUnitalNonAssocSemiring A] [DistribMulAction R A]
    [NonUnitalNonAssocSemiring B] [DistribMulAction R B]
    [FunLike F A B] [NonUnitalAlgHomClass F R A B] (f : F) : A →ₙₐ[R] B 
goal: A →ₙₐ[R] B

full_name: NonUnitalAlgHomClass.instCoeTCNonUnitalAlgHomId
code: instance {F R : Type*} [Monoid R] {A B : Type*}
    [NonUnitalNonAssocSemiring A] [DistribMulAction R A]
    [NonUnitalNonAssocSemiring B] [DistribMulAction R B]
    [FunLike F A B] [NonUnitalAlgHomClass F R A B] :
    CoeTC F (A →ₙₐ[R] B) 
goal: CoeTC F (A →ₙₐ[R] B)

full_name: NonUnitalAlgHom.instDFunLike
code: instance : DFunLike (A →ₛₙₐ[φ] B) A fun _ => B 
goal: DFunLike (A →ₛₙₐ[φ] B) A fun x => B

full_name: NonUnitalAlgHom.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : A →ₛₙₐ[φ] B) : f.toFun = ⇑f 
goal: f.toFun = ⇑f

full_name: NonUnitalAlgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (f : A →ₛₙₐ[φ] B) : A → B 
goal: A → B

full_name: NonUnitalAlgHom.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B]
    [NonUnitalAlgSemiHomClass F φ A B] (f : F) :
    ⇑(f : A →ₛₙₐ[φ] B) = f 
goal: ⇑↑f = ⇑f

full_name: NonUnitalAlgHom.coe_injective
code: theorem coe_injective : @Function.Injective (A →ₛₙₐ[φ] B) (A → B) (↑) 
goal: Function.Injective DFunLike.coe

full_name: NonUnitalAlgHom.instFunLike
code: instance : FunLike (A →ₛₙₐ[φ] B) A B 
goal: FunLike (A →ₛₙₐ[φ] B) A B

full_name: NonUnitalAlgHom.instNonUnitalAlgSemiHomClass
code: instance : NonUnitalAlgSemiHomClass (A →ₛₙₐ[φ] B) φ A B 
goal: NonUnitalAlgSemiHomClass (A →ₛₙₐ[φ] B) φ A B

full_name: NonUnitalAlgHom.ext
code: @[ext]
theorem ext {f g : A →ₛₙₐ[φ] B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: NonUnitalAlgHom.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: NonUnitalAlgHom.congr_fun
code: theorem congr_fun {f g : A →ₛₙₐ[φ] B} (h : f = g) (x : A) : f x = g x 
goal: f x = g x

full_name: NonUnitalAlgHom.coe_mk
code: @[simp]
theorem coe_mk (f : A → B) (h₁ h₂ h₃ h₄) : ⇑(⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →ₛₙₐ[φ] B) = f 
goal: ⇑{ toFun := f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } = f

full_name: NonUnitalAlgHom.mk_coe
code: @[simp]
theorem mk_coe (f : A →ₛₙₐ[φ] B) (h₁ h₂ h₃ h₄) : (⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →ₛₙₐ[φ] B) = f 
goal: { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } = f

full_name: NonUnitalAlgHom.instCoeOutDistribMulActionHom
code: instance : CoeOut (A →ₛₙₐ[φ] B) (A →ₑ+[φ] B) 
goal: CoeOut (A →ₛₙₐ[φ] B) (A →ₑ+[φ] B)

full_name: NonUnitalAlgHom.instCoeOutMulHom
code: instance : CoeOut (A →ₛₙₐ[φ] B) (A →ₙ* B) 
goal: CoeOut (A →ₛₙₐ[φ] B) (A →ₙ* B)

full_name: NonUnitalAlgHom.toDistribMulActionHom_eq_coe
code: @[simp]
theorem toDistribMulActionHom_eq_coe (f : A →ₛₙₐ[φ] B) : f.toDistribMulActionHom = ↑f 
goal: f.toDistribMulActionHom = ↑f

full_name: NonUnitalAlgHom.toMulHom_eq_coe
code: @[simp]
theorem toMulHom_eq_coe (f : A →ₛₙₐ[φ] B) : f.toMulHom = ↑f 
goal: f.toMulHom = ↑f

full_name: NonUnitalAlgHom.coe_to_distribMulActionHom
code: @[simp, norm_cast]
theorem coe_to_distribMulActionHom (f : A →ₛₙₐ[φ] B) : ⇑(f : A →ₑ+[φ] B) = f 
goal: ⇑↑f = ⇑f

full_name: NonUnitalAlgHom.coe_to_mulHom
code: @[simp, norm_cast]
theorem coe_to_mulHom (f : A →ₛₙₐ[φ] B) : ⇑(f : A →ₙ* B) = f 
goal: ⇑↑f = ⇑f

full_name: NonUnitalAlgHom.to_distribMulActionHom_injective
code: theorem to_distribMulActionHom_injective {f g : A →ₛₙₐ[φ] B}
    (h : (f : A →ₑ+[φ] B) = (g : A →ₑ+[φ] B)) : f = g 
goal: f = g

full_name: NonUnitalAlgHom.to_mulHom_injective
code: theorem to_mulHom_injective {f g : A →ₛₙₐ[φ] B} (h : (f : A →ₙ* B) = (g : A →ₙ* B)) : f = g 
goal: f = g

full_name: NonUnitalAlgHom.coe_distribMulActionHom_mk
code: @[norm_cast]
theorem coe_distribMulActionHom_mk (f : A →ₛₙₐ[φ] B) (h₁ h₂ h₃ h₄) :
    ((⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →ₛₙₐ[φ] B) : A →ₑ+[φ] B) = ⟨⟨f, h₁⟩, h₂, h₃⟩ 
goal: ↑{ toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } =
  { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }

full_name: NonUnitalAlgHom.coe_mulHom_mk
code: @[norm_cast]
theorem coe_mulHom_mk (f : A →ₛₙₐ[φ] B) (h₁ h₂ h₃ h₄) :
    ((⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →ₛₙₐ[φ] B) : A →ₙ* B) = ⟨f, h₄⟩ 
goal: ↑{ toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } = { toFun := ⇑f, map_mul' := h₄ }

full_name: NonUnitalAlgHom.map_smul
code: protected theorem map_smul (f : A →ₛₙₐ[φ] B) (c : R) (x : A) : f (c • x) = (φ c) • f x 
goal: f (c • x) = φ c • f x

full_name: NonUnitalAlgHom.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: NonUnitalAlgHom.map_mul
code: protected theorem map_mul (f : A →ₛₙₐ[φ] B) (x y : A) : f (x * y) = f x * f y 
goal: f (x * y) = f x * f y

full_name: NonUnitalAlgHom.map_zero
code: protected theorem map_zero (f : A →ₛₙₐ[φ] B) : f 0 = 0 
goal: f 0 = 0

full_name: NonUnitalAlgHom.id
code: /-- The identity map as a `NonUnitalAlgHom`. -/
protected def id (R A : Type*) [Monoid R] [NonUnitalNonAssocSemiring A]
    [DistribMulAction R A] : A →ₙₐ[R] A 
goal: A →ₙₐ[R] A

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

full_name: NonUnitalAlgHom.instZero
code: instance : Zero (A →ₛₙₐ[φ] B) 
goal: Zero (A →ₛₙₐ[φ] B)

full_name: NonUnitalAlgHom.instOneId
code: instance : One (A →ₙₐ[R] A) 
goal: One (A →ₙₐ[R] A)

full_name: NonUnitalAlgHom.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : A →ₛₙₐ[φ] B) = 0 
goal: ⇑0 = 0

full_name: NonUnitalAlgHom.coe_one
code: @[simp]
theorem coe_one : ((1 : A →ₙₐ[R] A) : A → A) = id 
goal: ⇑1 = id

full_name: NonUnitalAlgHom.zero_apply
code: theorem zero_apply (a : A) : (0 : A →ₛₙₐ[φ] B) a = 0 
goal: 0 a = 0

full_name: NonUnitalAlgHom.one_apply
code: theorem one_apply (a : A) : (1 : A →ₙₐ[R] A) a = a 
goal: 1 a = a

full_name: NonUnitalAlgHom.instInhabited
code: instance : Inhabited (A →ₛₙₐ[φ] B) 
goal: Inhabited (A →ₛₙₐ[φ] B)

full_name: NonUnitalAlgHom.comp
code: /-- The composition of morphisms is a morphism. -/
def comp (f : B →ₛₙₐ[ψ] C) (g : A →ₛₙₐ[φ] B) [κ : MonoidHom.CompTriple φ ψ χ] :
    A →ₛₙₐ[χ] C 
goal: A →ₛₙₐ[χ] C

full_name: NonUnitalAlgHom.coe_comp
code: @[simp, norm_cast]
theorem coe_comp (f : B →ₛₙₐ[ψ] C) (g : A →ₛₙₐ[φ] B) [MonoidHom.CompTriple φ ψ χ] :
    ⇑(f.comp g) = (⇑f) ∘ (⇑g) 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: NonUnitalAlgHom.comp_apply
code: theorem comp_apply (f : B →ₛₙₐ[ψ] C) (g : A →ₛₙₐ[φ] B) [MonoidHom.CompTriple φ ψ χ] (x : A) :
    f.comp g x = f (g x) 
goal: (f.comp g) x = f (g x)

full_name: NonUnitalAlgHom.inverse
code: /-- The inverse of a bijective morphism is a morphism. -/
def inverse (f : A →ₙₐ[R] B₁) (g : B₁ → A)
    (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : B₁ →ₙₐ[R] A 
goal: B₁ →ₙₐ[R] A

full_name: NonUnitalAlgHom.coe_inverse
code: @[simp]
theorem coe_inverse (f : A →ₙₐ[R] B₁) (g : B₁ → A) (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : (inverse f g h₁ h₂ : B₁ → A) = g 
goal: ⇑(f.inverse g h₁ h₂) = g

full_name: NonUnitalAlgHom.inverse'
code: /-- The inverse of a bijective morphism is a morphism. -/
def inverse' (f : A →ₛₙₐ[φ] B) (g : B → A)
    (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    B →ₛₙₐ[φ'] A 
goal: B →ₛₙₐ[φ'] A

full_name: NonUnitalAlgHom.coe_inverse'
code: @[simp]
theorem coe_inverse' (f : A →ₛₙₐ[φ] B) (g : B → A)
    (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    (inverse' f g k h₁ h₂ : B → A) = g 
goal: ⇑(f.inverse' g k h₁ h₂) = g

full_name: NonUnitalAlgHom.fst_apply
code: /-- The first projection of a product is a non-unital alg_hom. -/
@[simps]
def fst : A × B →ₙₐ[R] A 
goal: (NonUnitalAlgHom.fst R A B) self = self.1

full_name: NonUnitalAlgHom.fst
code: /-- The first projection of a product is a non-unital alg_hom. -/
@[simps]
def fst : A × B →ₙₐ[R] A 
goal: A × B →ₙₐ[R] A

full_name: NonUnitalAlgHom.fst_toFun
code: /-- The first projection of a product is a non-unital alg_hom. -/
@[simps]
def fst : A × B →ₙₐ[R] A 
goal: (NonUnitalAlgHom.fst R A B) self = self.1

full_name: NonUnitalAlgHom.snd
code: /-- The second projection of a product is a non-unital alg_hom. -/
@[simps]
def snd : A × B →ₙₐ[R] B 
goal: A × B →ₙₐ[R] B

full_name: NonUnitalAlgHom.snd_apply
code: /-- The second projection of a product is a non-unital alg_hom. -/
@[simps]
def snd : A × B →ₙₐ[R] B 
goal: (NonUnitalAlgHom.snd R A B) self = self.2

full_name: NonUnitalAlgHom.snd_toFun
code: /-- The second projection of a product is a non-unital alg_hom. -/
@[simps]
def snd : A × B →ₙₐ[R] B 
goal: (NonUnitalAlgHom.snd R A B) self = self.2

full_name: NonUnitalAlgHom.prod_toFun
code: /-- The prod of two morphisms is a morphism. -/
@[simps]
def prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : A →ₙₐ[R] B × C 
goal: (f.prod g) i = Pi.prod (⇑f) (⇑g) i

full_name: NonUnitalAlgHom.prod
code: /-- The prod of two morphisms is a morphism. -/
@[simps]
def prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : A →ₙₐ[R] B × C 
goal: A →ₙₐ[R] B × C

full_name: NonUnitalAlgHom.prod_apply
code: /-- The prod of two morphisms is a morphism. -/
@[simps]
def prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : A →ₙₐ[R] B × C 
goal: (f.prod g) i = Pi.prod (⇑f) (⇑g) i

full_name: NonUnitalAlgHom.coe_prod
code: theorem coe_prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: NonUnitalAlgHom.fst_prod
code: @[simp]
theorem fst_prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : (fst R B C).comp (prod f g) = f 
goal: (NonUnitalAlgHom.fst R B C).comp (f.prod g) = f

full_name: NonUnitalAlgHom.snd_prod
code: @[simp]
theorem snd_prod (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C) : (snd R B C).comp (prod f g) = g 
goal: (NonUnitalAlgHom.snd R B C).comp (f.prod g) = g

full_name: NonUnitalAlgHom.prod_fst_snd
code: @[simp]
theorem prod_fst_snd : prod (fst R A B) (snd R A B) = 1 
goal: (NonUnitalAlgHom.fst R A B).prod (NonUnitalAlgHom.snd R A B) = 1

full_name: NonUnitalAlgHom.prodEquiv_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₙₐ[R] B) × (A →ₙₐ[R] C) ≃ (A →ₙₐ[R] B × C) 
goal: NonUnitalAlgHom.prodEquiv f = f.1.prod f.2

full_name: NonUnitalAlgHom.prodEquiv
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₙₐ[R] B) × (A →ₙₐ[R] C) ≃ (A →ₙₐ[R] B × C) 
goal: (A →ₙₐ[R] B) × (A →ₙₐ[R] C) ≃ (A →ₙₐ[R] B × C)

full_name: NonUnitalAlgHom.prodEquiv_symm_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₙₐ[R] B) × (A →ₙₐ[R] C) ≃ (A →ₙₐ[R] B × C) 
goal: NonUnitalAlgHom.prodEquiv.symm f = ((NonUnitalAlgHom.fst R B C).comp f, (NonUnitalAlgHom.snd R B C).comp f)

full_name: NonUnitalAlgHom.inl
code: /-- The left injection into a product is a non-unital algebra homomorphism. -/
def inl : A →ₙₐ[R] A × B 
goal: A →ₙₐ[R] A × B

full_name: NonUnitalAlgHom.inr
code: /-- The right injection into a product is a non-unital algebra homomorphism. -/
def inr : B →ₙₐ[R] A × B 
goal: B →ₙₐ[R] A × B

full_name: NonUnitalAlgHom.coe_inl
code: @[simp]
theorem coe_inl : (inl R A B : A → A × B) = fun x => (x, 0) 
goal: ⇑(NonUnitalAlgHom.inl R A B) = fun x => (x, 0)

full_name: NonUnitalAlgHom.inl_apply
code: theorem inl_apply (x : A) : inl R A B x = (x, 0) 
goal: (NonUnitalAlgHom.inl R A B) x = (x, 0)

full_name: NonUnitalAlgHom.coe_inr
code: @[simp]
theorem coe_inr : (inr R A B : B → A × B) = Prod.mk 0 
goal: ⇑(NonUnitalAlgHom.inr R A B) = Prod.mk 0

full_name: NonUnitalAlgHom.inr_apply
code: theorem inr_apply (x : B) : inr R A B x = (0, x) 
goal: (NonUnitalAlgHom.inr R A B) x = (0, x)

full_name: AlgHom.instNonUnitalAlgHomClassOfAlgHomClass
code: instance (priority := 100) [FunLike F A B] [AlgHomClass F R A B] : NonUnitalAlgHomClass F R A B 
goal: NonUnitalAlgHomClass F R A B

full_name: AlgHom.toNonUnitalAlgHom
code: /-- A unital morphism of algebras is a `NonUnitalAlgHom`. -/
@[coe]
def toNonUnitalAlgHom (f : A →ₐ[R] B) : A →ₙₐ[R] B 
goal: A →ₙₐ[R] B

full_name: AlgHom.NonUnitalAlgHom.hasCoe
code: instance NonUnitalAlgHom.hasCoe : CoeOut (A →ₐ[R] B) (A →ₙₐ[R] B) 
goal: CoeOut (A →ₐ[R] B) (A →ₙₐ[R] B)

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

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

full_name: NonUnitalAlgHom.restrictScalars
code: /-- If a monoid `R` acts on another monoid `S`, then a non-unital algebra homomorphism
over `S` can be viewed as a non-unital algebra homomorphism over `R`.  -/
def restrictScalars (f : A →ₙₐ[S] B) : A →ₙₐ[R] B 
goal: A →ₙₐ[R] B

full_name: NonUnitalAlgHom.restrictScalars_apply
code: @[simp]
lemma restrictScalars_apply (f : A →ₙₐ[S] B) (x : A) : f.restrictScalars R x = f x 
goal: (NonUnitalAlgHom.restrictScalars R f) x = f x

full_name: NonUnitalAlgHom.coe_restrictScalars
code: lemma coe_restrictScalars (f : A →ₙₐ[S] B) : (f.restrictScalars R : A →ₙ+* B) = f 
goal: ↑(NonUnitalAlgHom.restrictScalars R f) = ↑f

full_name: NonUnitalAlgHom.coe_restrictScalars'
code: lemma coe_restrictScalars' (f : A →ₙₐ[S] B) : (f.restrictScalars R : A → B) = f 
goal: ⇑(NonUnitalAlgHom.restrictScalars R f) = ⇑f

full_name: NonUnitalAlgHom.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (A →ₙₐ[S] B) → A →ₙₐ[R] B) 
goal: Function.Injective (NonUnitalAlgHom.restrictScalars R)