File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

full_name: CategoryTheory.Adjunction.adjointOfOpAdjointOp_counit_app
code: /-- If `G.op` is adjoint to `F.op` then `F` is adjoint to `G`. -/
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on opAdjointOpOfAdjoint
@[simps! unit_app counit_app]
def adjointOfOpAdjointOp (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) : F ⊣ G 
goal: (CategoryTheory.Adjunction.adjointOfOpAdjointOp F G h).counit.app Y =
  (CategoryTheory.opEquiv (Opposite.op Y) (Opposite.op (F.obj (G.obj Y))))
    ((h.homEquiv (Opposite.op Y) (Opposite.op (G.obj Y)))
      ((CategoryTheory.opEquiv (Opposite.op (G.obj Y)) (Opposite.op (G.obj Y))).symm (𝟙 (G.obj Y))))

full_name: CategoryTheory.Adjunction.adjointOfOpAdjointOp_unit_app
code: /-- If `G.op` is adjoint to `F.op` then `F` is adjoint to `G`. -/
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on opAdjointOpOfAdjoint
@[simps! unit_app counit_app]
def adjointOfOpAdjointOp (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) : F ⊣ G 
goal: (CategoryTheory.Adjunction.adjointOfOpAdjointOp F G h).unit.app X =
  (CategoryTheory.opEquiv (Opposite.op (G.obj (F.obj X))) (Opposite.op X))
    ((h.homEquiv (Opposite.op (F.obj X)) (Opposite.op X)).symm
      ((CategoryTheory.opEquiv (Opposite.op (F.obj X)) (Opposite.op (F.obj X))).symm (𝟙 (F.obj X))))

full_name: CategoryTheory.Adjunction.adjointOfOpAdjointOp
code: /-- If `G.op` is adjoint to `F.op` then `F` is adjoint to `G`. -/
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on opAdjointOpOfAdjoint
@[simps! unit_app counit_app]
def adjointOfOpAdjointOp (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) : F ⊣ G 
goal: F ⊣ G

full_name: CategoryTheory.Adjunction.adjointUnopOfAdjointOp
code: /-- If `G` is adjoint to `F.op` then `F` is adjoint to `G.unop`. -/
def adjointUnopOfAdjointOp (F : C ⥤ D) (G : Dᵒᵖ ⥤ Cᵒᵖ) (h : G ⊣ F.op) : F ⊣ G.unop 
goal: F ⊣ G.unop

full_name: CategoryTheory.Adjunction.unopAdjointOfOpAdjoint
code: /-- If `G.op` is adjoint to `F` then `F.unop` is adjoint to `G`. -/
def unopAdjointOfOpAdjoint (F : Cᵒᵖ ⥤ Dᵒᵖ) (G : D ⥤ C) (h : G.op ⊣ F) : F.unop ⊣ G 
goal: F.unop ⊣ G

full_name: CategoryTheory.Adjunction.unopAdjointUnopOfAdjoint
code: /-- If `G` is adjoint to `F` then `F.unop` is adjoint to `G.unop`. -/
def unopAdjointUnopOfAdjoint (F : Cᵒᵖ ⥤ Dᵒᵖ) (G : Dᵒᵖ ⥤ Cᵒᵖ) (h : G ⊣ F) : F.unop ⊣ G.unop 
goal: F.unop ⊣ G.unop

full_name: CategoryTheory.Adjunction.opAdjointOpOfAdjoint_counit_app
code: /-- If `G` is adjoint to `F` then `F.op` is adjoint to `G.op`. -/
@[simps! unit_app counit_app]
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on adjointOfOpAdjointOp
def opAdjointOpOfAdjoint (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) : F.op ⊣ G.op 
goal: (CategoryTheory.Adjunction.opAdjointOpOfAdjoint F G h).counit.app Y =
  (CategoryTheory.opEquiv (Opposite.op (F.obj (G.obj (Opposite.unop Y)))) Y).symm
    (h.unit.app (Opposite.unop Y) ≫
      F.map
        ((CategoryTheory.opEquiv (Opposite.op (G.obj (Opposite.unop Y)))
            (Opposite.op (G.toPrefunctor.1 (Opposite.unop Y))))
          (𝟙 (Opposite.op (G.obj (Opposite.unop Y))))))

full_name: CategoryTheory.Adjunction.opAdjointOpOfAdjoint
code: /-- If `G` is adjoint to `F` then `F.op` is adjoint to `G.op`. -/
@[simps! unit_app counit_app]
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on adjointOfOpAdjointOp
def opAdjointOpOfAdjoint (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) : F.op ⊣ G.op 
goal: F.op ⊣ G.op

full_name: CategoryTheory.Adjunction.opAdjointOpOfAdjoint_unit_app
code: /-- If `G` is adjoint to `F` then `F.op` is adjoint to `G.op`. -/
@[simps! unit_app counit_app]
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on adjointOfOpAdjointOp
def opAdjointOpOfAdjoint (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) : F.op ⊣ G.op 
goal: (CategoryTheory.Adjunction.opAdjointOpOfAdjoint F G h).unit.app X =
  (CategoryTheory.opEquiv X (Opposite.op (G.toPrefunctor.1 (F.obj (Opposite.unop X))))).symm
    (G.map
        ((CategoryTheory.opEquiv (Opposite.op (F.obj (Opposite.unop X))) (Opposite.op (F.obj (Opposite.unop X))))
          (𝟙 (Opposite.op (F.obj (Opposite.unop X))))) ≫
      h.counit.app (Opposite.unop X))

full_name: CategoryTheory.Adjunction.adjointOpOfAdjointUnop
code: /-- If `G` is adjoint to `F.unop` then `F` is adjoint to `G.op`. -/
def adjointOpOfAdjointUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) (G : D ⥤ C) (h : G ⊣ F.unop) : F ⊣ G.op 
goal: F ⊣ G.op

full_name: CategoryTheory.Adjunction.opAdjointOfUnopAdjoint
code: /-- If `G.unop` is adjoint to `F` then `F.op` is adjoint to `G`. -/
def opAdjointOfUnopAdjoint (F : C ⥤ D) (G : Dᵒᵖ ⥤ Cᵒᵖ) (h : G.unop ⊣ F) : F.op ⊣ G 
goal: F.op ⊣ G

full_name: CategoryTheory.Adjunction.adjointOfUnopAdjointUnop
code: /-- If `G.unop` is adjoint to `F.unop` then `F` is adjoint to `G`. -/
def adjointOfUnopAdjointUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) (G : Dᵒᵖ ⥤ Cᵒᵖ) (h : G.unop ⊣ F.unop) : F ⊣ G 
goal: F ⊣ G

full_name: CategoryTheory.Adjunction.leftAdjointsCoyonedaEquiv
code: /-- If `F` and `F'` are both adjoint to `G`, there is a natural isomorphism
`F.op ⋙ coyoneda ≅ F'.op ⋙ coyoneda`.
We use this in combination with `fullyFaithfulCancelRight` to show left adjoints are unique.
-/
def leftAdjointsCoyonedaEquiv {F F' : C ⥤ D} {G : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) :
    F.op ⋙ coyoneda ≅ F'.op ⋙ coyoneda 
goal: F.op ⋙ CategoryTheory.coyoneda ≅ F'.op ⋙ CategoryTheory.coyoneda

full_name: CategoryTheory.Adjunction.natIsoOfRightAdjointNatIso
code: /-- Given two adjunctions, if the right adjoints are naturally isomorphic, then so are the left
adjoints.

Note: it is generally better to use `Adjunction.natIsoEquiv`, see the file `Adjunction.Unique`.
The reason this definition still exists is that apparently `CategoryTheory.extendAlongYonedaYoneda`
uses its definitional properties (TODO: figure out a way to avoid this).
-/
def natIsoOfRightAdjointNatIso {F F' : C ⥤ D} {G G' : D ⥤ C}
    (adj1 : F ⊣ G) (adj2 : F' ⊣ G') (r : G ≅ G') : F ≅ F' 
goal: F ≅ F'

full_name: CategoryTheory.Adjunction.natIsoOfLeftAdjointNatIso
code: /-- Given two adjunctions, if the left adjoints are naturally isomorphic, then so are the right
adjoints.

Note: it is generally better to use `Adjunction.natIsoEquiv`, see the file `Adjunction.Unique`.
-/
def natIsoOfLeftAdjointNatIso {F F' : C ⥤ D} {G G' : D ⥤ C}
    (adj1 : F ⊣ G) (adj2 : F' ⊣ G') (l : F ≅ F') : G ≅ G' 
goal: G ≅ G'