File: Mathlib/CategoryTheory/Linear/Yoneda.lean

full_name: CategoryTheory.linearYoneda_obj_obj
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `X : C` to the `Module R`-valued presheaf on `C`,
with value on `Y : Cᵒᵖ` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
goal: ((CategoryTheory.linearYoneda R C).obj X).obj Y = ModuleCat.of R (Opposite.unop Y ⟶ X)

full_name: CategoryTheory.linearYoneda_map_app
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `X : C` to the `Module R`-valued presheaf on `C`,
with value on `Y : Cᵒᵖ` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
goal: ((CategoryTheory.linearYoneda R C).map f).app Y =
  ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y) f)

full_name: CategoryTheory.linearYoneda
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `X : C` to the `Module R`-valued presheaf on `C`,
with value on `Y : Cᵒᵖ` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
goal: CategoryTheory.Functor C (CategoryTheory.Functor Cᵒᵖ (ModuleCat R))

full_name: CategoryTheory.linearYoneda_obj_map
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `X : C` to the `Module R`-valued presheaf on `C`,
with value on `Y : Cᵒᵖ` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y),
  ((CategoryTheory.linearYoneda R C).obj X).map f = ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X f.unop)

full_name: CategoryTheory.linearCoyoneda_obj_obj
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `Y : Cᵒᵖ` to the `Module R`-valued copresheaf on `C`,
with value on `X : C` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
goal: ((CategoryTheory.linearCoyoneda R C).obj Y).obj X = ModuleCat.of R (Opposite.unop Y ⟶ X)

full_name: CategoryTheory.linearCoyoneda_obj_map
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `Y : Cᵒᵖ` to the `Module R`-valued copresheaf on `C`,
with value on `X : C` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
goal: ∀ {X Y_1 : C} (f : X ⟶ Y_1),
  ((CategoryTheory.linearCoyoneda R C).obj Y).map f =
    ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y) f)

full_name: CategoryTheory.linearCoyoneda
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `Y : Cᵒᵖ` to the `Module R`-valued copresheaf on `C`,
with value on `X : C` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
goal: CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor C (ModuleCat R))

full_name: CategoryTheory.linearCoyoneda_map_app
code: /-- The Yoneda embedding for `R`-linear categories `C`,
sending an object `Y : Cᵒᵖ` to the `Module R`-valued copresheaf on `C`,
with value on `X : C` given by `Module.of R (unop Y ⟶ X)`. -/
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
goal: ((CategoryTheory.linearCoyoneda R C).map f).app X = ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X f.unop)

full_name: CategoryTheory.linearYoneda_obj_additive
code: instance linearYoneda_obj_additive (X : C) : ((linearYoneda R C).obj X).Additive 
goal: ((CategoryTheory.linearYoneda R C).obj X).Additive

full_name: CategoryTheory.linearCoyoneda_obj_additive
code: instance linearCoyoneda_obj_additive (Y : Cᵒᵖ) : ((linearCoyoneda R C).obj Y).Additive 
goal: ((CategoryTheory.linearCoyoneda R C).obj Y).Additive

full_name: CategoryTheory.whiskering_linearYoneda
code: @[simp]
theorem whiskering_linearYoneda :
    linearYoneda R C ⋙ (whiskeringRight _ _ _).obj (forget (ModuleCat.{v} R)) = yoneda 
goal: (CategoryTheory.linearYoneda R C).comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ (ModuleCat R) (Type v)).obj (CategoryTheory.forget (ModuleCat R))) =
  CategoryTheory.yoneda

full_name: CategoryTheory.whiskering_linearYoneda₂
code: @[simp]
theorem whiskering_linearYoneda₂ :
    linearYoneda R C ⋙ (whiskeringRight _ _ _).obj (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}) =
      preadditiveYoneda 
goal: (CategoryTheory.linearYoneda R C).comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ (ModuleCat R) AddCommGrp).obj
      (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)) =
  CategoryTheory.preadditiveYoneda

full_name: CategoryTheory.whiskering_linearCoyoneda
code: @[simp]
theorem whiskering_linearCoyoneda :
    linearCoyoneda R C ⋙ (whiskeringRight _ _ _).obj (forget (ModuleCat.{v} R)) = coyoneda 
goal: (CategoryTheory.linearCoyoneda R C).comp
    ((CategoryTheory.whiskeringRight C (ModuleCat R) (Type v)).obj (CategoryTheory.forget (ModuleCat R))) =
  CategoryTheory.coyoneda

full_name: CategoryTheory.whiskering_linearCoyoneda₂
code: @[simp]
theorem whiskering_linearCoyoneda₂ :
    linearCoyoneda R C ⋙
        (whiskeringRight _ _ _).obj (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}) =
      preadditiveCoyoneda 
goal: (CategoryTheory.linearCoyoneda R C).comp
    ((CategoryTheory.whiskeringRight C (ModuleCat R) AddCommGrp).obj
      (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)) =
  CategoryTheory.preadditiveCoyoneda

full_name: CategoryTheory.full_linearYoneda
code: instance full_linearYoneda : (linearYoneda R C).Full 
goal: (CategoryTheory.linearYoneda R C).Full

full_name: CategoryTheory.full_linearCoyoneda
code: instance full_linearCoyoneda : (linearCoyoneda R C).Full 
goal: (CategoryTheory.linearCoyoneda R C).Full

full_name: CategoryTheory.faithful_linearYoneda
code: instance faithful_linearYoneda : (linearYoneda R C).Faithful 
goal: (CategoryTheory.linearYoneda R C).Faithful

full_name: CategoryTheory.faithful_linearCoyoneda
code: instance faithful_linearCoyoneda : (linearCoyoneda R C).Faithful 
goal: (CategoryTheory.linearCoyoneda R C).Faithful