File: Mathlib/CategoryTheory/Adjunction/Comma.lean

full_name: CategoryTheory.leftAdjointOfStructuredArrowInitialsAux
code: /-- Implementation: If each structured arrow category on `G` has an initial object, an equivalence
which is helpful for constructing a left adjoint to `G`.
-/
@[simps]
def leftAdjointOfStructuredArrowInitialsAux (A : C) (B : D) :
    ((⊥_ StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B) 
goal: ((⊥_ CategoryTheory.StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B)

full_name: CategoryTheory.leftAdjointOfStructuredArrowInitialsAux_apply
code: /-- Implementation: If each structured arrow category on `G` has an initial object, an equivalence
which is helpful for constructing a left adjoint to `G`.
-/
@[simps]
def leftAdjointOfStructuredArrowInitialsAux (A : C) (B : D) :
    ((⊥_ StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B) 
goal: (CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G A B) g =
  CategoryTheory.CategoryStruct.comp (⊥_ CategoryTheory.StructuredArrow A G).hom (G.map g)

full_name: CategoryTheory.leftAdjointOfStructuredArrowInitialsAux_symm_apply
code: /-- Implementation: If each structured arrow category on `G` has an initial object, an equivalence
which is helpful for constructing a left adjoint to `G`.
-/
@[simps]
def leftAdjointOfStructuredArrowInitialsAux (A : C) (B : D) :
    ((⊥_ StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B) 
goal: (CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G A B).symm f =
  (CategoryTheory.Limits.initial.to (CategoryTheory.StructuredArrow.mk f)).right

full_name: CategoryTheory.leftAdjointOfStructuredArrowInitials
code: /--
If each structured arrow category on `G` has an initial object, construct a left adjoint to `G`. It
is shown that it is a left adjoint in `adjunctionOfStructuredArrowInitials`.
-/
def leftAdjointOfStructuredArrowInitials : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.adjunctionOfStructuredArrowInitials
code: /--
If each structured arrow category on `G` has an initial object, we have a constructed left adjoint
to `G`.
-/
def adjunctionOfStructuredArrowInitials : leftAdjointOfStructuredArrowInitials G ⊣ G 
goal: CategoryTheory.leftAdjointOfStructuredArrowInitials G ⊣ G

full_name: CategoryTheory.isRightAdjointOfStructuredArrowInitials
code: /-- If each structured arrow category on `G` has an initial object, `G` is a right adjoint. -/
lemma isRightAdjointOfStructuredArrowInitials : G.IsRightAdjoint 
goal: G.IsRightAdjoint

full_name: CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux_symm_apply
code: /-- Implementation: If each costructured arrow category on `G` has a terminal object, an equivalence
which is helpful for constructing a right adjoint to `G`.
-/
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left) 
goal: (CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux G B A).symm g =
  CategoryTheory.CategoryStruct.comp (G.map g) (⊤_ CategoryTheory.CostructuredArrow G A).hom

full_name: CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux_apply
code: /-- Implementation: If each costructured arrow category on `G` has a terminal object, an equivalence
which is helpful for constructing a right adjoint to `G`.
-/
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left) 
goal: (CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux G B A) g =
  (CategoryTheory.Limits.terminal.from (CategoryTheory.CostructuredArrow.mk g)).left

full_name: CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux
code: /-- Implementation: If each costructured arrow category on `G` has a terminal object, an equivalence
which is helpful for constructing a right adjoint to `G`.
-/
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left) 
goal: (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CategoryTheory.CostructuredArrow G A).left)

full_name: CategoryTheory.rightAdjointOfCostructuredArrowTerminals
code: /--
If each costructured arrow category on `G` has a terminal object, construct a right adjoint to `G`.
It is shown that it is a right adjoint in `adjunctionOfStructuredArrowInitials`.
-/
def rightAdjointOfCostructuredArrowTerminals : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.adjunctionOfCostructuredArrowTerminals
code: /-- If each costructured arrow category on `G` has a terminal object, we have a constructed right
adjoint to `G`.
-/
def adjunctionOfCostructuredArrowTerminals : G ⊣ rightAdjointOfCostructuredArrowTerminals G 
goal: G ⊣ CategoryTheory.rightAdjointOfCostructuredArrowTerminals G

full_name: CategoryTheory.isLeftAdjoint_of_costructuredArrowTerminals
code: /-- If each costructured arrow category on `G` has a terminal object, `G` is a left adjoint. -/
lemma isLeftAdjoint_of_costructuredArrowTerminals : G.IsLeftAdjoint 
goal: G.IsLeftAdjoint

full_name: CategoryTheory.mkInitialOfLeftAdjoint
code: /-- Given a left adjoint to `G`, we can construct an initial object in each structured arrow
category on `G`. -/
def mkInitialOfLeftAdjoint (h : F ⊣ G) (A : C) :
    IsInitial (StructuredArrow.mk (h.unit.app A) : StructuredArrow A G) 
goal: CategoryTheory.Limits.IsInitial (CategoryTheory.StructuredArrow.mk (h.unit.app A))

full_name: CategoryTheory.mkTerminalOfRightAdjoint
code: /-- Given a right adjoint to `F`, we can construct a terminal object in each costructured arrow
category on `F`. -/
def mkTerminalOfRightAdjoint (h : F ⊣ G) (A : D) :
    IsTerminal (CostructuredArrow.mk (h.counit.app A) : CostructuredArrow F A) 
goal: CategoryTheory.Limits.IsTerminal (CategoryTheory.CostructuredArrow.mk (h.counit.app A))

full_name: CategoryTheory.isRightAdjoint_iff_hasInitial_structuredArrow
code: theorem isRightAdjoint_iff_hasInitial_structuredArrow {G : D ⥤ C} :
    G.IsRightAdjoint ↔ ∀ A, HasInitial (StructuredArrow A G) 
goal: G.IsRightAdjoint ↔ ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)

full_name: CategoryTheory.isLeftAdjoint_iff_hasTerminal_costructuredArrow
code: theorem isLeftAdjoint_iff_hasTerminal_costructuredArrow {F : C ⥤ D} :
    F.IsLeftAdjoint ↔ ∀ A, HasTerminal (CostructuredArrow F A) 
goal: F.IsLeftAdjoint ↔ ∀ (A : D), CategoryTheory.Limits.HasTerminal (CategoryTheory.CostructuredArrow F A)