File: Mathlib/Algebra/Category/ModuleCat/Basic.lean

full_name: ModuleCat
code: /-- The category of R-modules and their morphisms.

 Note that in the case of `R = ℤ`, we can not
impose here that the `ℤ`-multiplication field from the module structure is defeq to the one coming
from the `isAddCommGroup` structure (contrary to what we do for all module structures in
mathlib), which creates some difficulties down the road. -/
structure ModuleCat where
  /-- the underlying type of an object in `ModuleCat R` -/
  carrier : Type v
  [isAddCommGroup : AddCommGroup carrier]
  [isModule : Module R carrier]
goal: Type (max u (v + 1))

full_name: ModuleCat.isModule
code: /-- The category of R-modules and their morphisms.

 Note that in the case of `R = ℤ`, we can not
impose here that the `ℤ`-multiplication field from the module structure is defeq to the one coming
from the `isAddCommGroup` structure (contrary to what we do for all module structures in
mathlib), which creates some difficulties down the road. -/
structure ModuleCat where
  /-- the underlying type of an object in `ModuleCat R` -/
  carrier : Type v
  [isAddCommGroup : AddCommGroup carrier]
  [isModule : Module R carrier]
goal: Module R ↑self

full_name: ModuleCat.isAddCommGroup
code: /-- The category of R-modules and their morphisms.

 Note that in the case of `R = ℤ`, we can not
impose here that the `ℤ`-multiplication field from the module structure is defeq to the one coming
from the `isAddCommGroup` structure (contrary to what we do for all module structures in
mathlib), which creates some difficulties down the road. -/
structure ModuleCat where
  /-- the underlying type of an object in `ModuleCat R` -/
  carrier : Type v
  [isAddCommGroup : AddCommGroup carrier]
  [isModule : Module R carrier]
goal: AddCommGroup ↑self

full_name: ModuleCat.carrier
code: /-- The category of R-modules and their morphisms.

 Note that in the case of `R = ℤ`, we can not
impose here that the `ℤ`-multiplication field from the module structure is defeq to the one coming
from the `isAddCommGroup` structure (contrary to what we do for all module structures in
mathlib), which creates some difficulties down the road. -/
structure ModuleCat where
  /-- the underlying type of an object in `ModuleCat R` -/
  carrier : Type v
  [isAddCommGroup : AddCommGroup carrier]
  [isModule : Module R carrier]
goal: Type v

full_name: ModuleCatMax
code: /-- An alias for `ModuleCat.{max u₁ u₂}`, to deal around unification issues.
Since the universe the ring lives in can be inferred, we put that last. -/
@[nolint checkUnivs]
abbrev ModuleCatMax.{v₁, v₂, u₁} (R : Type u₁) [Ring R] 
goal: Type (max u₁ ((max v₁ v₂) + 1))

full_name: ModuleCat.instCoeSortType
code: instance : CoeSort (ModuleCat.{v} R) (Type v) 
goal: CoeSort (ModuleCat R) (Type v)

full_name: ModuleCat.moduleCategory
code: instance moduleCategory : Category.{v, max (v+1) u} (ModuleCat.{v} R) 
goal: CategoryTheory.Category.{v, max (v + 1) u} (ModuleCat R)

full_name: ModuleCat.instFunLikeHomCarrier
code: instance {M N : ModuleCat.{v} R} : FunLike (M ⟶ N) M N 
goal: FunLike (M ⟶ N) ↑M ↑N

full_name: ModuleCat.instLinearMapClassHomCarrier
code: instance {M N : ModuleCat.{v} R} : LinearMapClass (M ⟶ N) R M N 
goal: LinearMapClass (M ⟶ N) R ↑M ↑N

full_name: ModuleCat.moduleConcreteCategory
code: instance moduleConcreteCategory : ConcreteCategory.{v} (ModuleCat.{v} R) 
goal: CategoryTheory.ConcreteCategory (ModuleCat R)

full_name: ModuleCat.instAddCommGroupObjForget
code: instance {M : ModuleCat.{v} R} : AddCommGroup ((forget (ModuleCat R)).obj M) 
goal: AddCommGroup ((CategoryTheory.forget (ModuleCat R)).obj M)

full_name: ModuleCat.instModuleObjForget
code: instance {M : ModuleCat.{v} R} : Module R ((forget (ModuleCat R)).obj M) 
goal: Module R ((CategoryTheory.forget (ModuleCat R)).obj M)

full_name: ModuleCat.ext
code: @[ext]
lemma ext {M N : ModuleCat.{v} R} {f₁ f₂ : M ⟶ N} (h : ∀ (x : M), f₁ x = f₂ x) : f₁ = f₂ 
goal: f₁ = f₂

full_name: ModuleCat.hasForgetToAddCommGroup
code: instance hasForgetToAddCommGroup : HasForget₂ (ModuleCat R) AddCommGrp 
goal: CategoryTheory.HasForget₂ (ModuleCat R) AddCommGrp

full_name: ModuleCat.of
code: /-- The object in the category of R-modules associated to an R-module -/
def of (X : Type v) [AddCommGroup X] [Module R X] : ModuleCat R 
goal: ModuleCat R

full_name: ModuleCat.forget₂_obj
code: @[simp]
theorem forget₂_obj (X : ModuleCat R) :
    (forget₂ (ModuleCat R) AddCommGrp).obj X = AddCommGrp.of X 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj X = AddCommGrp.of ↑X

full_name: ModuleCat.forget₂_obj_moduleCat_of
code: theorem forget₂_obj_moduleCat_of (X : Type v) [AddCommGroup X] [Module R X] :
    (forget₂ (ModuleCat R) AddCommGrp).obj (of R X) = AddCommGrp.of X 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj (ModuleCat.of R X) = AddCommGrp.of X

full_name: ModuleCat.forget₂_map
code: @[simp]
theorem forget₂_map (X Y : ModuleCat R) (f : X ⟶ Y) :
    (forget₂ (ModuleCat R) AddCommGrp).map f = LinearMap.toAddMonoidHom f 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f = LinearMap.toAddMonoidHom f

full_name: ModuleCat.ofHom
code: /-- Typecheck a `LinearMap` as a morphism in `Module R`. -/
def ofHom {R : Type u} [Ring R] {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y]
    [Module R Y] (f : X →ₗ[R] Y) : of R X ⟶ of R Y 
goal: ModuleCat.of R X ⟶ ModuleCat.of R Y

full_name: ModuleCat.ofHom_apply
code: @[simp 1100]
theorem ofHom_apply {R : Type u} [Ring R] {X Y : Type v} [AddCommGroup X] [Module R X]
    [AddCommGroup Y] [Module R Y] (f : X →ₗ[R] Y) (x : X) : ofHom f x = f x 
goal: (ModuleCat.ofHom f) x = f x

full_name: ModuleCat.instInhabited
code: instance : Inhabited (ModuleCat R) 
goal: Inhabited (ModuleCat R)

full_name: ModuleCat.ofUnique
code: instance ofUnique {X : Type v} [AddCommGroup X] [Module R X] [i : Unique X] : Unique (of R X) 
goal: Unique ↑(ModuleCat.of R X)

full_name: ModuleCat.of_coe
code: @[simp] theorem of_coe (X : ModuleCat R) : of R X = X 
goal: ModuleCat.of R ↑X = X

full_name: ModuleCat.coe_of
code: theorem coe_of (X : Type v) [AddCommGroup X] [Module R X] : (of R X : Type v) = X 
goal: ↑(ModuleCat.of R X) = X

full_name: ModuleCat.ofSelfIso_hom
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
module. -/
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M 
goal: M.ofSelfIso.hom = 𝟙 M

full_name: ModuleCat.ofSelfIso_inv
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
module. -/
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M 
goal: M.ofSelfIso.inv = 𝟙 M

full_name: ModuleCat.ofSelfIso
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
module. -/
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M 
goal: ModuleCat.of R ↑M ≅ M

full_name: ModuleCat.isZero_of_subsingleton
code: theorem isZero_of_subsingleton (M : ModuleCat R) [Subsingleton M] : IsZero M 
goal: CategoryTheory.Limits.IsZero M

full_name: ModuleCat.instHasZeroObject
code: instance : HasZeroObject (ModuleCat.{v} R) 
goal: CategoryTheory.Limits.HasZeroObject (ModuleCat R)

full_name: ModuleCat.id_apply
code: @[simp]
theorem id_apply (m : M) : (𝟙 M : M → M) m = m 
goal: (𝟙 M) m = m

full_name: ModuleCat.coe_comp
code: @[simp]
theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: ModuleCat.comp_def
code: theorem comp_def (f : M ⟶ N) (g : N ⟶ U) : f ≫ g = g.comp f 
goal: f ≫ g = g ∘ₗ f

full_name: ModuleCat.forget_map
code: @[simp] lemma forget_map (f : M ⟶ N) : (forget (ModuleCat R)).map f = (f : M → N) 
goal: (CategoryTheory.forget (ModuleCat R)).map f = ⇑f

full_name: ModuleCat.asHom
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
def ModuleCat.asHom [AddCommGroup X₁] [Module R X₁] [AddCommGroup X₂] [Module R X₂] :
    (X₁ →ₗ[R] X₂) → (ModuleCat.of R X₁ ⟶ ModuleCat.of R X₂) 
goal: (X₁ →ₗ[R] X₂) → (ModuleCat.of R X₁ ⟶ ModuleCat.of R X₂)

full_name: ModuleCat._aux_Mathlib_Algebra_Category_ModuleCat_Basic___unexpand_ModuleCat_asHom_1
code: /-- Reinterpreting a linear map in the category of `R`-modules -/
scoped[ModuleCat] notation "↟" f:1024 => ModuleCat.asHom f
goal: Lean.PrettyPrinter.Unexpander

full_name: ModuleCat.«_aux_Mathlib_Algebra_Category_ModuleCat_Basic___macroRules_ModuleCat_term↟__1»
code: /-- Reinterpreting a linear map in the category of `R`-modules -/
scoped[ModuleCat] notation "↟" f:1024 => ModuleCat.asHom f
goal: Lean.Macro

full_name: ModuleCat.asHomRight
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
def ModuleCat.asHomRight [AddCommGroup X₁] [Module R X₁] {X₂ : ModuleCat.{v} R} :
    (X₁ →ₗ[R] X₂) → (ModuleCat.of R X₁ ⟶ X₂) 
goal: (X₁ →ₗ[R] ↑X₂) → (ModuleCat.of R X₁ ⟶ X₂)

full_name: ModuleCat.«_aux_Mathlib_Algebra_Category_ModuleCat_Basic___macroRules_ModuleCat_term↾__1»
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
scoped[ModuleCat] notation "↾" f:1024 => ModuleCat.asHomRight f
goal: Lean.Macro

full_name: ModuleCat._aux_Mathlib_Algebra_Category_ModuleCat_Basic___unexpand_ModuleCat_asHomRight_1
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
scoped[ModuleCat] notation "↾" f:1024 => ModuleCat.asHomRight f
goal: Lean.PrettyPrinter.Unexpander

full_name: ModuleCat.asHomLeft
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
def ModuleCat.asHomLeft {X₁ : ModuleCat.{v} R} [AddCommGroup X₂] [Module R X₂] :
    (X₁ →ₗ[R] X₂) → (X₁ ⟶ ModuleCat.of R X₂) 
goal: (↑X₁ →ₗ[R] X₂) → (X₁ ⟶ ModuleCat.of R X₂)

full_name: ModuleCat.«_aux_Mathlib_Algebra_Category_ModuleCat_Basic___macroRules_ModuleCat_term↿__1»
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
scoped[ModuleCat] notation "↿" f:1024 => ModuleCat.asHomLeft f
goal: Lean.Macro

full_name: ModuleCat._aux_Mathlib_Algebra_Category_ModuleCat_Basic___unexpand_ModuleCat_asHomLeft_1
code: /-- Reinterpreting a linear map in the category of `R`-modules. -/
scoped[ModuleCat] notation "↿" f:1024 => ModuleCat.asHomLeft f
goal: Lean.PrettyPrinter.Unexpander

full_name: LinearEquiv.toModuleIso_inv
code: /-- Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. -/
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂ 
goal: e.toModuleIso.inv = ↑e.symm

full_name: LinearEquiv.toModuleIso_hom
code: /-- Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. -/
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂ 
goal: e.toModuleIso.hom = ↑e

full_name: LinearEquiv.toModuleIso
code: /-- Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. -/
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂ 
goal: ModuleCat.of R X₁ ≅ ModuleCat.of R X₂

full_name: LinearEquiv.toModuleIso'
code: /-- Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. -/
abbrev LinearEquiv.toModuleIso' {M N : ModuleCat.{v} R} (i : M ≃ₗ[R] N) : M ≅ N 
goal: M ≅ N

full_name: LinearEquiv.toModuleIso'Left
code: /-- Build an isomorphism in the category `ModuleCat R` from a `LinearEquiv` between `Module`s. -/
abbrev LinearEquiv.toModuleIso'Left {X₁ : ModuleCat.{v} R} [AddCommGroup X₂] [Module R X₂]
    (e : X₁ ≃ₗ[R] X₂) : X₁ ≅ ModuleCat.of R X₂ 
goal: X₁ ≅ ModuleCat.of R X₂

full_name: LinearEquiv.toModuleIso'Right
code: /-- Build an isomorphism in the category `ModuleCat R` from a `LinearEquiv` between `Module`s. -/
abbrev LinearEquiv.toModuleIso'Right [AddCommGroup X₁] [Module R X₁] {X₂ : ModuleCat.{v} R}
    (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ X₂ 
goal: ModuleCat.of R X₁ ≅ X₂

full_name: CategoryTheory.Iso.toLinearEquiv
code: /-- Build a `LinearEquiv` from an isomorphism in the category `ModuleCat R`. -/
def toLinearEquiv {X Y : ModuleCat R} (i : X ≅ Y) : X ≃ₗ[R] Y 
goal: ↑X ≃ₗ[R] ↑Y

full_name: linearEquivIsoModuleIso
code: /-- linear equivalences between `Module`s are the same as (isomorphic to) isomorphisms
in `ModuleCat` -/
@[simps]
def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X]
    [Module R Y] : (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y 
goal: (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y

full_name: linearEquivIsoModuleIso_hom
code: /-- linear equivalences between `Module`s are the same as (isomorphic to) isomorphisms
in `ModuleCat` -/
@[simps]
def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X]
    [Module R Y] : (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y 
goal: linearEquivIsoModuleIso.hom e = e.toModuleIso

full_name: linearEquivIsoModuleIso_inv
code: /-- linear equivalences between `Module`s are the same as (isomorphic to) isomorphisms
in `ModuleCat` -/
@[simps]
def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X]
    [Module R Y] : (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y 
goal: linearEquivIsoModuleIso.inv i = i.toLinearEquiv

full_name: ModuleCat.instAddCommGroupHom
code: instance {M N : ModuleCat.{v} R} : AddCommGroup (M ⟶ N) 
goal: AddCommGroup (M ⟶ N)

full_name: ModuleCat.instPreadditive
code: instance : Preadditive (ModuleCat.{v} R) 
goal: CategoryTheory.Preadditive (ModuleCat R)

full_name: ModuleCat.forget₂_addCommGrp_additive
code: instance forget₂_addCommGrp_additive :
    (forget₂ (ModuleCat.{v} R) AddCommGrp).Additive 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).Additive

full_name: ModuleCat.instLinear
code: instance : Linear S (ModuleCat.{v} S) 
goal: CategoryTheory.Linear S (ModuleCat S)

full_name: ModuleCat.Iso.homCongr_eq_arrowCongr
code: theorem Iso.homCongr_eq_arrowCongr (i : X ≅ X') (j : Y ≅ Y') (f : X ⟶ Y) :
    Iso.homCongr i j f = LinearEquiv.arrowCongr i.toLinearEquiv j.toLinearEquiv f 
goal: (i.homCongr j) f = (i.toLinearEquiv.arrowCongr j.toLinearEquiv) f

full_name: ModuleCat.Iso.conj_eq_conj
code: theorem Iso.conj_eq_conj (i : X ≅ X') (f : End X) :
    Iso.conj i f = LinearEquiv.conj i.toLinearEquiv f 
goal: i.conj f = i.toLinearEquiv.conj f

full_name: ModuleCat.smul
code: /-- The scalar multiplication on an object of `ModuleCat R` considered as
a morphism of rings from `R` to the endomorphisms of the underlying abelian group. -/
def smul : R →+* End ((forget₂ (ModuleCat R) AddCommGrp).obj M) 
goal: R →+* CategoryTheory.End ((CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj M)

full_name: ModuleCat.smul_naturality
code: lemma smul_naturality {M N : ModuleCat.{v} R} (f : M ⟶ N) (r : R) :
    (forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r =
      M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r =
  M.smul r ≫ (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f

full_name: ModuleCat.smulNatTrans_apply_app
code: /-- The scalar multiplication on `ModuleCat R` considered as a morphism of rings
to the endomorphisms of the forgetful functor to `AddCommGrp)`. -/
@[simps]
def smulNatTrans : R →+* End (forget₂ (ModuleCat R) AddCommGrp) 
goal: ((ModuleCat.smulNatTrans R) r).app M = M.smul r

full_name: ModuleCat.smulNatTrans
code: /-- The scalar multiplication on `ModuleCat R` considered as a morphism of rings
to the endomorphisms of the forgetful functor to `AddCommGrp)`. -/
@[simps]
def smulNatTrans : R →+* End (forget₂ (ModuleCat R) AddCommGrp) 
goal: R →+* CategoryTheory.End (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

full_name: ModuleCat.mkOfSMul'
code: /-- Given `A : AddCommGrp` and a ring morphism `R →+* End A`, this is a type synonym
for `A`, on which we shall define a structure of `R`-module. -/
@[nolint unusedArguments]
def mkOfSMul' {A : AddCommGrp} (_ : R →+* End A) 
goal: (R →+* CategoryTheory.End A) → AddCommGrp

full_name: ModuleCat.instAddCommGroupαMkOfSMul'
code: instance : AddCommGroup (mkOfSMul' φ) 
goal: AddCommGroup ↑(ModuleCat.mkOfSMul' φ)

full_name: ModuleCat.instSMulαAddCommGroupMkOfSMul'
code: instance : SMul R (mkOfSMul' φ) 
goal: SMul R ↑(ModuleCat.mkOfSMul' φ)

full_name: ModuleCat.mkOfSMul'_smul
code: @[simp]
lemma mkOfSMul'_smul (r : R) (x : mkOfSMul' φ) :
    r • x = (show A ⟶ A from φ r) x 
goal: r • x =
  (let_fun this := φ r;
    this)
    x

full_name: ModuleCat.instModuleαAddCommGroupMkOfSMul'
code: instance : Module R (mkOfSMul' φ) 
goal: Module R ↑(ModuleCat.mkOfSMul' φ)

full_name: ModuleCat.mkOfSMul
code: /-- Given `A : AddCommGrp` and a ring morphism `R →+* End A`, this is an object in
`ModuleCat R`, whose underlying abelian group is `A` and whose scalar multiplication is
given by `R`. -/
abbrev mkOfSMul 
goal: ModuleCat R

full_name: ModuleCat.mkOfSMul_smul
code: @[simp, nolint simpNF]
lemma mkOfSMul_smul (r : R) : (mkOfSMul φ).smul r = φ r 
goal: (ModuleCat.mkOfSMul φ).smul r = φ r

full_name: ModuleCat.homMk
code: /-- Constructor for morphisms in `ModuleCat R` which takes as inputs
a morphism between the underlying objects in `AddCommGrp` and the compatibility
with the scalar multiplication. -/
@[simps]
def homMk : M ⟶ N 
goal: M ⟶ N

full_name: ModuleCat.homMk_apply
code: /-- Constructor for morphisms in `ModuleCat R` which takes as inputs
a morphism between the underlying objects in `AddCommGrp` and the compatibility
with the scalar multiplication. -/
@[simps]
def homMk : M ⟶ N 
goal: (ModuleCat.homMk φ hφ) a = φ a

full_name: ModuleCat.forget₂_map_homMk
code: lemma forget₂_map_homMk :
    (forget₂ (ModuleCat R) AddCommGrp).map (homMk φ hφ) = φ 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map (ModuleCat.homMk φ hφ) = φ

full_name: ModuleCat.instReflectsIsomorphismsForget
code: instance : (forget (ModuleCat.{v} R)).ReflectsIsomorphisms 
goal: (CategoryTheory.forget (ModuleCat R)).ReflectsIsomorphisms

full_name: ModuleCat.instReflectsIsomorphismsAddCommGrpForget₂
code: instance : (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).ReflectsIsomorphisms

full_name: LinearMap.comp_id_moduleCat
code: @[simp] theorem LinearMap.comp_id_moduleCat
    {R} [Ring R] {G : ModuleCat.{u} R} {H : Type u} [AddCommGroup H] [Module R H] (f : G →ₗ[R] H) :
    f.comp (𝟙 G) = f 
goal: f ∘ₗ 𝟙 G = f

full_name: LinearMap.id_moduleCat_comp
code: @[simp] theorem LinearMap.id_moduleCat_comp
    {R} [Ring R] {G : Type u} [AddCommGroup G] [Module R G] {H : ModuleCat.{u} R} (f : G →ₗ[R] H) :
    LinearMap.comp (𝟙 H) f = f 
goal: 𝟙 H ∘ₗ f = f