File: Mathlib/CategoryTheory/Functor/Const.lean

full_name: CategoryTheory.Functor.const_obj_obj
code: /-- The functor sending `X : C` to the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def const : C ⥤ J ⥤ C 
goal: ∀ (x : J), ((CategoryTheory.Functor.const J).obj X).obj x = X

full_name: CategoryTheory.Functor.const_map_app
code: /-- The functor sending `X : C` to the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def const : C ⥤ J ⥤ C 
goal: ∀ {X Y : C} (f : X ⟶ Y) (x : J), ((CategoryTheory.Functor.const J).map f).app x = f

full_name: CategoryTheory.Functor.const
code: /-- The functor sending `X : C` to the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def const : C ⥤ J ⥤ C 
goal: C ⥤ J ⥤ C

full_name: CategoryTheory.Functor.const_obj_map
code: /-- The functor sending `X : C` to the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def const : C ⥤ J ⥤ C 
goal: ∀ {X_1 Y : J} (x : X_1 ⟶ Y), ((CategoryTheory.Functor.const J).obj X).map x = 𝟙 X

full_name: CategoryTheory.Functor.const.opObjOp_inv_app
code: /-- The constant functor `Jᵒᵖ ⥤ Cᵒᵖ` sending everything to `op X`
is (naturally isomorphic to) the opposite of the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def opObjOp (X : C) : (const Jᵒᵖ).obj (op X) ≅ ((const J).obj X).op 
goal: (CategoryTheory.Functor.const.opObjOp X).inv.app j = 𝟙 (((CategoryTheory.Functor.const J).obj X).op.obj j)

full_name: CategoryTheory.Functor.const.opObjOp
code: /-- The constant functor `Jᵒᵖ ⥤ Cᵒᵖ` sending everything to `op X`
is (naturally isomorphic to) the opposite of the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def opObjOp (X : C) : (const Jᵒᵖ).obj (op X) ≅ ((const J).obj X).op 
goal: (CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.op X) ≅ ((CategoryTheory.Functor.const J).obj X).op

full_name: CategoryTheory.Functor.const.opObjOp_hom_app
code: /-- The constant functor `Jᵒᵖ ⥤ Cᵒᵖ` sending everything to `op X`
is (naturally isomorphic to) the opposite of the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def opObjOp (X : C) : (const Jᵒᵖ).obj (op X) ≅ ((const J).obj X).op 
goal: (CategoryTheory.Functor.const.opObjOp X).hom.app j = 𝟙 (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.op X)).obj j)

full_name: CategoryTheory.Functor.const.opObjUnop
code: /-- The constant functor `Jᵒᵖ ⥤ C` sending everything to `unop X`
is (naturally isomorphic to) the opposite of
the constant functor `J ⥤ Cᵒᵖ` sending everything to `X`.
-/
def opObjUnop (X : Cᵒᵖ) : (const Jᵒᵖ).obj (unop X) ≅ ((const J).obj X).leftOp 
goal: (CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.unop X) ≅ ((CategoryTheory.Functor.const J).obj X).leftOp

full_name: CategoryTheory.Functor.const.opObjUnop_hom_app
code: @[simp]
theorem opObjUnop_hom_app (X : Cᵒᵖ) (j : Jᵒᵖ) : (opObjUnop.{v₁, v₂} X).hom.app j = 𝟙 _ 
goal: (CategoryTheory.Functor.const.opObjUnop X).hom.app j =
  𝟙 (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.unop X)).obj j)

full_name: CategoryTheory.Functor.const.opObjUnop_inv_app
code: @[simp]
theorem opObjUnop_inv_app (X : Cᵒᵖ) (j : Jᵒᵖ) : (opObjUnop.{v₁, v₂} X).inv.app j = 𝟙 _ 
goal: (CategoryTheory.Functor.const.opObjUnop X).inv.app j = 𝟙 (((CategoryTheory.Functor.const J).obj X).leftOp.obj j)

full_name: CategoryTheory.Functor.const.unop_functor_op_obj_map
code: @[simp]
theorem unop_functor_op_obj_map (X : Cᵒᵖ) {j₁ j₂ : J} (f : j₁ ⟶ j₂) :
    (unop ((Functor.op (const J)).obj X)).map f = 𝟙 (unop X) 
goal: (Opposite.unop ((CategoryTheory.Functor.const J).op.obj X)).map f = 𝟙 (Opposite.unop X)

full_name: CategoryTheory.Functor.constComp_inv_app
code: /-- These are actually equal, of course, but not definitionally equal
  (the equality requires F.map (𝟙 _) = 𝟙 _). A natural isomorphism is
  more convenient than an equality between functors (compare id_to_iso). -/
@[simps]
def constComp (X : C) (F : C ⥤ D) : (const J).obj X ⋙ F ≅ (const J).obj (F.obj X) 
goal: ∀ (x : J),
  (CategoryTheory.Functor.constComp J X F).inv.app x = 𝟙 (((CategoryTheory.Functor.const J).obj (F.obj X)).obj x)

full_name: CategoryTheory.Functor.constComp
code: /-- These are actually equal, of course, but not definitionally equal
  (the equality requires F.map (𝟙 _) = 𝟙 _). A natural isomorphism is
  more convenient than an equality between functors (compare id_to_iso). -/
@[simps]
def constComp (X : C) (F : C ⥤ D) : (const J).obj X ⋙ F ≅ (const J).obj (F.obj X) 
goal: (CategoryTheory.Functor.const J).obj X ⋙ F ≅ (CategoryTheory.Functor.const J).obj (F.obj X)

full_name: CategoryTheory.Functor.constComp_hom_app
code: /-- These are actually equal, of course, but not definitionally equal
  (the equality requires F.map (𝟙 _) = 𝟙 _). A natural isomorphism is
  more convenient than an equality between functors (compare id_to_iso). -/
@[simps]
def constComp (X : C) (F : C ⥤ D) : (const J).obj X ⋙ F ≅ (const J).obj (F.obj X) 
goal: ∀ (x : J), (CategoryTheory.Functor.constComp J X F).hom.app x = 𝟙 (((CategoryTheory.Functor.const J).obj X ⋙ F).obj x)

full_name: CategoryTheory.Functor.instFaithfulConstOfNonempty
code: /-- If `J` is nonempty, then the constant functor over `J` is faithful. -/
instance [Nonempty J] : Faithful (const J : C ⥤ J ⥤ C) 
goal: (CategoryTheory.Functor.const J).Faithful

full_name: CategoryTheory.Functor.compConstIso_inv_app_app
code: /-- The canonical isomorphism
`F ⋙ Functor.const J ≅ Functor.const F ⋙ (whiskeringRight J _ _).obj L`. -/
@[simps!]
def compConstIso (F : C ⥤ D) :
    F ⋙ Functor.const J ≅ Functor.const J ⋙ (whiskeringRight J C D).obj F 
goal: ∀ (X_1 : J), ((CategoryTheory.Functor.compConstIso J F).inv.app X).app X_1 = 𝟙 (F.obj X)

full_name: CategoryTheory.Functor.compConstIso_hom_app_app
code: /-- The canonical isomorphism
`F ⋙ Functor.const J ≅ Functor.const F ⋙ (whiskeringRight J _ _).obj L`. -/
@[simps!]
def compConstIso (F : C ⥤ D) :
    F ⋙ Functor.const J ≅ Functor.const J ⋙ (whiskeringRight J C D).obj F 
goal: ∀ (X_1 : J), ((CategoryTheory.Functor.compConstIso J F).hom.app X).app X_1 = 𝟙 (F.obj X)

full_name: CategoryTheory.Functor.compConstIso
code: /-- The canonical isomorphism
`F ⋙ Functor.const J ≅ Functor.const F ⋙ (whiskeringRight J _ _).obj L`. -/
@[simps!]
def compConstIso (F : C ⥤ D) :
    F ⋙ Functor.const J ≅ Functor.const J ⋙ (whiskeringRight J C D).obj F 
goal: F ⋙ CategoryTheory.Functor.const J ≅ CategoryTheory.Functor.const J ⋙ (CategoryTheory.whiskeringRight J C D).obj F