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

full_name: FGModuleCat
code: /-- Define `FGModuleCat` as the subtype of `ModuleCat.{u} R` of finitely generated modules. -/
def FGModuleCat 
goal: Type (u + 1)

full_name: FGModuleCat.carrier
code: /-- A synonym for `M.obj.carrier`, which we can mark with `@[coe]`. -/
def FGModuleCat.carrier (M : FGModuleCat R) : Type u 
goal: Type u

full_name: instCoeSortFGModuleCatType
code: instance : CoeSort (FGModuleCat R) (Type u) 
goal: CoeSort (FGModuleCat R) (Type u)

full_name: obj_carrier
code: @[simp] lemma obj_carrier (M : FGModuleCat R) : M.obj.carrier = M.carrier 
goal: ↑M.obj = ↑M

full_name: instAddCommGroupCarrier
code: instance (M : FGModuleCat R) : AddCommGroup M 
goal: AddCommGroup ↑M

full_name: instModuleCarrier
code: instance (M : FGModuleCat R) : Module R M 
goal: Module R ↑M

full_name: instLargeCategoryFGModuleCat
code: instance : LargeCategory (FGModuleCat R) 
goal: CategoryTheory.LargeCategory (FGModuleCat R)

full_name: instFunLikeHomFGModuleCatCarrier
code: instance {M N : FGModuleCat R} : FunLike (M ⟶ N) M N 
goal: FunLike (M ⟶ N) ↑M ↑N

full_name: instLinearMapClassHomFGModuleCatCarrier
code: instance {M N : FGModuleCat R} : LinearMapClass (M ⟶ N) R M N 
goal: LinearMapClass (M ⟶ N) R ↑M ↑N

full_name: instConcreteCategoryFGModuleCat
code: instance : ConcreteCategory (FGModuleCat R) 
goal: CategoryTheory.ConcreteCategory (FGModuleCat R)

full_name: instPreadditiveFGModuleCat
code: instance : Preadditive (FGModuleCat R) 
goal: CategoryTheory.Preadditive (FGModuleCat R)

full_name: FGModuleCat.finite
code: instance finite (V : FGModuleCat R) : Module.Finite R V 
goal: Module.Finite R ↑V

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

full_name: FGModuleCat.of
code: /-- Lift an unbundled finitely generated module to `FGModuleCat R`. -/
def of (V : Type u) [AddCommGroup V] [Module R V] [Module.Finite R V] : FGModuleCat R 
goal: FGModuleCat R

full_name: FGModuleCat.instFiniteCarrier
code: instance (V : FGModuleCat R) : Module.Finite R V 
goal: Module.Finite R ↑V

full_name: FGModuleCat.instHasForget₂ModuleCat
code: instance : HasForget₂ (FGModuleCat.{u} R) (ModuleCat.{u} R) 
goal: CategoryTheory.HasForget₂ (FGModuleCat R) (ModuleCat R)

full_name: FGModuleCat.instFullModuleCatForget₂
code: instance : (forget₂ (FGModuleCat R) (ModuleCat.{u} R)).Full 
goal: (CategoryTheory.forget₂ (FGModuleCat R) (ModuleCat R)).Full

full_name: FGModuleCat.isoToLinearEquiv
code: /-- Converts and isomorphism in the category `FGModuleCat R` to
a `LinearEquiv` between the underlying modules. -/
def isoToLinearEquiv {V W : FGModuleCat R} (i : V ≅ W) : V ≃ₗ[R] W 
goal: ↑V ≃ₗ[R] ↑W

full_name: LinearEquiv.toFGModuleCatIso_inv
code: /-- Converts a `LinearEquiv` to an isomorphism in the category `FGModuleCat R`. -/
@[simps]
def _root_.LinearEquiv.toFGModuleCatIso
    {V W : Type u} [AddCommGroup V] [Module R V] [Module.Finite R V]
    [AddCommGroup W] [Module R W] [Module.Finite R W] (e : V ≃ₗ[R] W) :
    FGModuleCat.of R V ≅ FGModuleCat.of R W 
goal: e.toFGModuleCatIso.inv = ↑e.symm

full_name: LinearEquiv.toFGModuleCatIso
code: /-- Converts a `LinearEquiv` to an isomorphism in the category `FGModuleCat R`. -/
@[simps]
def _root_.LinearEquiv.toFGModuleCatIso
    {V W : Type u} [AddCommGroup V] [Module R V] [Module.Finite R V]
    [AddCommGroup W] [Module R W] [Module.Finite R W] (e : V ≃ₗ[R] W) :
    FGModuleCat.of R V ≅ FGModuleCat.of R W 
goal: FGModuleCat.of R V ≅ FGModuleCat.of R W

full_name: LinearEquiv.toFGModuleCatIso_hom
code: /-- Converts a `LinearEquiv` to an isomorphism in the category `FGModuleCat R`. -/
@[simps]
def _root_.LinearEquiv.toFGModuleCatIso
    {V W : Type u} [AddCommGroup V] [Module R V] [Module.Finite R V]
    [AddCommGroup W] [Module R W] [Module.Finite R W] (e : V ≃ₗ[R] W) :
    FGModuleCat.of R V ≅ FGModuleCat.of R W 
goal: e.toFGModuleCatIso.hom = ↑e

full_name: FGModuleCat.instLinear
code: instance : Linear R (FGModuleCat R) 
goal: CategoryTheory.Linear R (FGModuleCat R)

full_name: FGModuleCat.monoidalPredicate_module_finite
code: instance monoidalPredicate_module_finite :
    MonoidalCategory.MonoidalPredicate fun V : ModuleCat.{u} R => Module.Finite R V 
goal: CategoryTheory.MonoidalCategory.MonoidalPredicate fun V => Module.Finite R ↑V

full_name: FGModuleCat.instMonoidalCategory
code: instance : MonoidalCategory (FGModuleCat R) 
goal: CategoryTheory.MonoidalCategory (FGModuleCat R)

full_name: FGModuleCat.tensorUnit_obj
code: @[simp] lemma tensorUnit_obj : (𝟙_ (FGModuleCat R)).obj = 𝟙_ (ModuleCat R) 
goal: (𝟙_ (FGModuleCat R)).obj = 𝟙_ (ModuleCat R)

full_name: FGModuleCat.tensorObj_obj
code: @[simp] lemma tensorObj_obj (M N : FGModuleCat.{u} R) : (M ⊗ N).obj = (M.obj ⊗ N.obj) 
goal: (CategoryTheory.MonoidalCategory.tensorObj M N).obj = CategoryTheory.MonoidalCategory.tensorObj M.obj N.obj

full_name: FGModuleCat.instSymmetricCategory
code: instance : SymmetricCategory (FGModuleCat R) 
goal: CategoryTheory.SymmetricCategory (FGModuleCat R)

full_name: FGModuleCat.instMonoidalPreadditive
code: instance : MonoidalPreadditive (FGModuleCat R) 
goal: CategoryTheory.MonoidalPreadditive (FGModuleCat R)

full_name: FGModuleCat.instMonoidalLinear
code: instance : MonoidalLinear R (FGModuleCat R) 
goal: CategoryTheory.MonoidalLinear R (FGModuleCat R)

full_name: FGModuleCat.forget₂Monoidal
code: /-- The forgetful functor `FGModuleCat R ⥤ Module R` as a monoidal functor. -/
def forget₂Monoidal : MonoidalFunctor (FGModuleCat R) (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalFunctor (FGModuleCat R) (ModuleCat R)

full_name: FGModuleCat.forget₂Monoidal_faithful
code: instance forget₂Monoidal_faithful : (forget₂Monoidal R).Faithful 
goal: (FGModuleCat.forget₂Monoidal R).Faithful

full_name: FGModuleCat.forget₂Monoidal_additive
code: instance forget₂Monoidal_additive : (forget₂Monoidal R).Additive 
goal: (FGModuleCat.forget₂Monoidal R).Additive

full_name: FGModuleCat.forget₂Monoidal_linear
code: instance forget₂Monoidal_linear : (forget₂Monoidal R).Linear R 
goal: CategoryTheory.Functor.Linear R (FGModuleCat.forget₂Monoidal R).toFunctor

full_name: FGModuleCat.Iso.conj_eq_conj
code: theorem Iso.conj_eq_conj {V W : FGModuleCat R} (i : V ≅ W) (f : End V) :
    Iso.conj i f = LinearEquiv.conj (isoToLinearEquiv i) f 
goal: i.conj f = (FGModuleCat.isoToLinearEquiv i).conj f

full_name: FGModuleCat.instFiniteHom
code: instance (V W : FGModuleCat K) : Module.Finite K (V ⟶ W) 
goal: Module.Finite K (V ⟶ W)

full_name: FGModuleCat.closedPredicateModuleFinite
code: instance closedPredicateModuleFinite :
    MonoidalCategory.ClosedPredicate fun V : ModuleCat.{u} K ↦ Module.Finite K V 
goal: CategoryTheory.MonoidalCategory.ClosedPredicate fun V => Module.Finite K ↑V

full_name: FGModuleCat.instMonoidalClosed
code: instance : MonoidalClosed (FGModuleCat K) 
goal: CategoryTheory.MonoidalClosed (FGModuleCat K)

full_name: FGModuleCat.ihom_obj
code: @[simp]
theorem ihom_obj : (ihom V).obj W = FGModuleCat.of K (V →ₗ[K] W) 
goal: (CategoryTheory.ihom V).obj W = FGModuleCat.of K (↑V →ₗ[K] ↑W)

full_name: FGModuleCat.FGModuleCatDual
code: /-- The dual module is the dual in the rigid monoidal category `FGModuleCat K`. -/
def FGModuleCatDual : FGModuleCat K 
goal: FGModuleCat K

full_name: FGModuleCat.FGModuleCatDual_obj
code: @[simp] lemma FGModuleCatDual_obj : (FGModuleCatDual K V).obj = ModuleCat.of K (Module.Dual K V) 
goal: (FGModuleCat.FGModuleCatDual K V).obj = ModuleCat.of K (Module.Dual K ↑V)

full_name: FGModuleCat.FGModuleCatDual_coe
code: @[simp] lemma FGModuleCatDual_coe : (FGModuleCatDual K V : Type u) = Module.Dual K V 
goal: ↑(FGModuleCat.FGModuleCatDual K V) = Module.Dual K ↑V

full_name: FGModuleCat.FGModuleCatCoevaluation
code: /-- The coevaluation map is defined in `LinearAlgebra.coevaluation`. -/
def FGModuleCatCoevaluation : 𝟙_ (FGModuleCat K) ⟶ V ⊗ FGModuleCatDual K V 
goal: 𝟙_ (FGModuleCat K) ⟶ CategoryTheory.MonoidalCategory.tensorObj V (FGModuleCat.FGModuleCatDual K V)

full_name: FGModuleCat.FGModuleCatCoevaluation_apply_one
code: theorem FGModuleCatCoevaluation_apply_one :
    FGModuleCatCoevaluation K V (1 : K) =
      ∑ i : Basis.ofVectorSpaceIndex K V,
        (Basis.ofVectorSpace K V) i ⊗ₜ[K] (Basis.ofVectorSpace K V).coord i 
goal: (FGModuleCat.FGModuleCatCoevaluation K V) 1 =
  ∑ i : ↑(Basis.ofVectorSpaceIndex K ↑V), (Basis.ofVectorSpace K ↑V) i ⊗ₜ[K] (Basis.ofVectorSpace K ↑V).coord i

full_name: FGModuleCat.FGModuleCatEvaluation
code: /-- The evaluation morphism is given by the contraction map. -/
def FGModuleCatEvaluation : FGModuleCatDual K V ⊗ V ⟶ 𝟙_ (FGModuleCat K) 
goal: CategoryTheory.MonoidalCategory.tensorObj (FGModuleCat.FGModuleCatDual K V) V ⟶ 𝟙_ (FGModuleCat K)

full_name: FGModuleCat.FGModuleCatEvaluation_apply
code: @[simp]
theorem FGModuleCatEvaluation_apply (f : FGModuleCatDual K V) (x : V) :
    (FGModuleCatEvaluation K V) (f ⊗ₜ x) = f.toFun x 
goal: (FGModuleCat.FGModuleCatEvaluation K V) (f ⊗ₜ[K] x) = f.toFun x

full_name: _private.Mathlib.Algebra.Category.FGModuleCat.Basic.0.FGModuleCat.coevaluation_evaluation
code: private theorem coevaluation_evaluation :
    letI V' : FGModuleCat K := FGModuleCatDual K V
    V' ◁ FGModuleCatCoevaluation K V ≫ (α_ V' V V').inv ≫ FGModuleCatEvaluation K V ▷ V' =
      (ρ_ V').hom ≫ (λ_ V').inv 
goal: CategoryTheory.MonoidalCategory.whiskerLeft (FGModuleCat.FGModuleCatDual K V)
      (FGModuleCat.FGModuleCatCoevaluation K V) ≫
    (CategoryTheory.MonoidalCategory.associator (FGModuleCat.FGModuleCatDual K V) V
          (FGModuleCat.FGModuleCatDual K V)).inv ≫
      CategoryTheory.MonoidalCategory.whiskerRight (FGModuleCat.FGModuleCatEvaluation K V)
        (FGModuleCat.FGModuleCatDual K V) =
  (CategoryTheory.MonoidalCategory.rightUnitor (FGModuleCat.FGModuleCatDual K V)).hom ≫
    (CategoryTheory.MonoidalCategory.leftUnitor (FGModuleCat.FGModuleCatDual K V)).inv

full_name: _private.Mathlib.Algebra.Category.FGModuleCat.Basic.0.FGModuleCat.evaluation_coevaluation
code: private theorem evaluation_coevaluation :
    FGModuleCatCoevaluation K V ▷ V ≫
        (α_ V (FGModuleCatDual K V) V).hom ≫ V ◁ FGModuleCatEvaluation K V =
      (λ_ V).hom ≫ (ρ_ V).inv 
goal: CategoryTheory.MonoidalCategory.whiskerRight (FGModuleCat.FGModuleCatCoevaluation K V) V ≫
    (CategoryTheory.MonoidalCategory.associator V (FGModuleCat.FGModuleCatDual K V) V).hom ≫
      CategoryTheory.MonoidalCategory.whiskerLeft V (FGModuleCat.FGModuleCatEvaluation K V) =
  (CategoryTheory.MonoidalCategory.leftUnitor V).hom ≫ (CategoryTheory.MonoidalCategory.rightUnitor V).inv

full_name: FGModuleCat.exactPairing
code: instance exactPairing : ExactPairing V (FGModuleCatDual K V) 
goal: CategoryTheory.ExactPairing V (FGModuleCat.FGModuleCatDual K V)

full_name: FGModuleCat.rightDual
code: instance rightDual : HasRightDual V 
goal: CategoryTheory.HasRightDual V

full_name: FGModuleCat.rightRigidCategory
code: instance rightRigidCategory : RightRigidCategory (FGModuleCat K) 
goal: CategoryTheory.RightRigidCategory (FGModuleCat K)

full_name: LinearMap.comp_id_fgModuleCat
code: @[simp] theorem LinearMap.comp_id_fgModuleCat
    {R} [Ring R] {G : FGModuleCat.{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_fgModuleCat_comp
code: @[simp] theorem LinearMap.id_fgModuleCat_comp
    {R} [Ring R] {G : Type u} [AddCommGroup G] [Module R G] {H : FGModuleCat.{u} R}
    (f : G →ₗ[R] H) : LinearMap.comp (𝟙 H) f = f 
goal: 𝟙 H ∘ₗ f = f