File: Mathlib/CategoryTheory/Preadditive/Yoneda/Basic.lean

full_name: CategoryTheory.preadditiveYonedaObj
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the `End Y`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveYonedaObj (Y : C) : Cᵒᵖ ⥤ ModuleCat.{v} (End Y) 
goal: CategoryTheory.Functor Cᵒᵖ (ModuleCat (CategoryTheory.End Y))

full_name: CategoryTheory.preadditiveYonedaObj_obj
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the `End Y`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveYonedaObj (Y : C) : Cᵒᵖ ⥤ ModuleCat.{v} (End Y) 
goal: (CategoryTheory.preadditiveYonedaObj Y).obj X = ModuleCat.of (CategoryTheory.End Y) (Opposite.unop X ⟶ Y)

full_name: CategoryTheory.preadditiveYonedaObj_map
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the `End Y`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveYonedaObj (Y : C) : Cᵒᵖ ⥤ ModuleCat.{v} (End Y) 
goal: ∀ {X Y_1 : Cᵒᵖ} (f : X ⟶ Y_1),
  (CategoryTheory.preadditiveYonedaObj Y).map f =
    ModuleCat.ofHom { toFun := fun g => CategoryTheory.CategoryStruct.comp f.unop g, map_add' := ⋯, map_smul' := ⋯ }

full_name: CategoryTheory.preadditiveYoneda_map_app_apply
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End Y`-module
structure, see `preadditiveYonedaObj`.
-/
@[simps]
def preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp.{v} 
goal: ∀ {X Y : C} (f : X ⟶ Y) (X_1 : Cᵒᵖ)
  (g :
    ↑(((fun Y =>
              (CategoryTheory.preadditiveYonedaObj Y).comp
                (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End Y)) AddCommGrp))
            X).obj
        X_1)),
  ((CategoryTheory.preadditiveYoneda.map f).app X_1) g = CategoryTheory.CategoryStruct.comp g f

full_name: CategoryTheory.preadditiveYoneda
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End Y`-module
structure, see `preadditiveYonedaObj`.
-/
@[simps]
def preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp.{v} 
goal: CategoryTheory.Functor C (CategoryTheory.Functor Cᵒᵖ AddCommGrp)

full_name: CategoryTheory.preadditiveYoneda_obj
code: /-- The Yoneda embedding for preadditive categories sends an object `Y` to the presheaf sending an
object `X` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End Y`-module
structure, see `preadditiveYonedaObj`.
-/
@[simps]
def preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp.{v} 
goal: CategoryTheory.preadditiveYoneda.obj Y =
  (CategoryTheory.preadditiveYonedaObj Y).comp (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End Y)) AddCommGrp)

full_name: CategoryTheory.preadditiveCoyonedaObj_map
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the `End X`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveCoyonedaObj (X : Cᵒᵖ) : C ⥤ ModuleCat.{v} (End X) 
goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  (CategoryTheory.preadditiveCoyonedaObj X).map f =
    ModuleCat.ofHom { toFun := fun g => CategoryTheory.CategoryStruct.comp g f, map_add' := ⋯, map_smul' := ⋯ }

full_name: CategoryTheory.preadditiveCoyonedaObj
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the `End X`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveCoyonedaObj (X : Cᵒᵖ) : C ⥤ ModuleCat.{v} (End X) 
goal: CategoryTheory.Functor C (ModuleCat (CategoryTheory.End X))

full_name: CategoryTheory.preadditiveCoyonedaObj_obj
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the `End X`-module of morphisms `X ⟶ Y`.
-/
@[simps]
def preadditiveCoyonedaObj (X : Cᵒᵖ) : C ⥤ ModuleCat.{v} (End X) 
goal: (CategoryTheory.preadditiveCoyonedaObj X).obj Y = ModuleCat.of (CategoryTheory.End X) (Opposite.unop X ⟶ Y)

full_name: CategoryTheory.preadditiveCoyoneda
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End X`-module
structure, see `preadditiveCoyonedaObj`.
-/
@[simps]
def preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{v} 
goal: CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor C AddCommGrp)

full_name: CategoryTheory.preadditiveCoyoneda_obj
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End X`-module
structure, see `preadditiveCoyonedaObj`.
-/
@[simps]
def preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{v} 
goal: CategoryTheory.preadditiveCoyoneda.obj X =
  (CategoryTheory.preadditiveCoyonedaObj X).comp (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End X)) AddCommGrp)

full_name: CategoryTheory.preadditiveCoyoneda_map_app_apply
code: /-- The Yoneda embedding for preadditive categories sends an object `X` to the copresheaf sending an
object `Y` to the group of morphisms `X ⟶ Y`. At each point, we get an additional `End X`-module
structure, see `preadditiveCoyonedaObj`.
-/
@[simps]
def preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{v} 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (Y_1 : C)
  (g :
    ↑(((fun X =>
              (CategoryTheory.preadditiveCoyonedaObj X).comp
                (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End X)) AddCommGrp))
            X).obj
        Y_1)),
  ((CategoryTheory.preadditiveCoyoneda.map f).app Y_1) g = CategoryTheory.CategoryStruct.comp f.unop g

full_name: CategoryTheory.additive_yonedaObj
code: instance additive_yonedaObj (X : C) : Functor.Additive (preadditiveYonedaObj X) 
goal: (CategoryTheory.preadditiveYonedaObj X).Additive

full_name: CategoryTheory.additive_yonedaObj'
code: instance additive_yonedaObj' (X : C) : Functor.Additive (preadditiveYoneda.obj X) 
goal: (CategoryTheory.preadditiveYoneda.obj X).Additive

full_name: CategoryTheory.additive_coyonedaObj
code: instance additive_coyonedaObj (X : Cᵒᵖ) : Functor.Additive (preadditiveCoyonedaObj X) 
goal: (CategoryTheory.preadditiveCoyonedaObj X).Additive

full_name: CategoryTheory.additive_coyonedaObj'
code: instance additive_coyonedaObj' (X : Cᵒᵖ) : Functor.Additive (preadditiveCoyoneda.obj X) 
goal: (CategoryTheory.preadditiveCoyoneda.obj X).Additive

full_name: CategoryTheory.whiskering_preadditiveYoneda
code: /-- Composing the preadditive yoneda embedding with the forgetful functor yields the regular
Yoneda embedding.
-/
@[simp]
theorem whiskering_preadditiveYoneda :
    preadditiveYoneda ⋙
        (whiskeringRight Cᵒᵖ AddCommGrp (Type v)).obj (forget AddCommGrp) =
      yoneda 
goal: CategoryTheory.preadditiveYoneda.comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ AddCommGrp (Type v)).obj (CategoryTheory.forget AddCommGrp)) =
  CategoryTheory.yoneda

full_name: CategoryTheory.whiskering_preadditiveCoyoneda
code: /-- Composing the preadditive yoneda embedding with the forgetful functor yields the regular
Yoneda embedding.
-/
@[simp]
theorem whiskering_preadditiveCoyoneda :
    preadditiveCoyoneda ⋙
        (whiskeringRight C AddCommGrp (Type v)).obj (forget AddCommGrp) =
      coyoneda 
goal: CategoryTheory.preadditiveCoyoneda.comp
    ((CategoryTheory.whiskeringRight C AddCommGrp (Type v)).obj (CategoryTheory.forget AddCommGrp)) =
  CategoryTheory.coyoneda

full_name: CategoryTheory.full_preadditiveYoneda
code: instance full_preadditiveYoneda : (preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp).Full 
goal: CategoryTheory.preadditiveYoneda.Full

full_name: CategoryTheory.full_preadditiveCoyoneda
code: instance full_preadditiveCoyoneda : (preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp).Full 
goal: CategoryTheory.preadditiveCoyoneda.Full

full_name: CategoryTheory.faithful_preadditiveYoneda
code: instance faithful_preadditiveYoneda : (preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp).Faithful 
goal: CategoryTheory.preadditiveYoneda.Faithful

full_name: CategoryTheory.faithful_preadditiveCoyoneda
code: instance faithful_preadditiveCoyoneda :
    (preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp).Faithful 
goal: CategoryTheory.preadditiveCoyoneda.Faithful