File: Mathlib/CategoryTheory/Monad/Adjunction.lean

full_name: CategoryTheory.Adjunction.toMonad_η
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a monad on
the category `C`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps! coe η μ]
def toMonad (h : L ⊣ R) : Monad C 
goal: h.toMonad.η = h.unit

full_name: CategoryTheory.Adjunction.toMonad
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a monad on
the category `C`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps! coe η μ]
def toMonad (h : L ⊣ R) : Monad C 
goal: CategoryTheory.Monad C

full_name: CategoryTheory.Adjunction.toMonad_coe
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a monad on
the category `C`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps! coe η μ]
def toMonad (h : L ⊣ R) : Monad C 
goal: h.toMonad.toFunctor = L.comp R

full_name: CategoryTheory.Adjunction.toMonad_μ
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a monad on
the category `C`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps! coe η μ]
def toMonad (h : L ⊣ R) : Monad C 
goal: h.toMonad.μ = CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft L h.counit) R

full_name: CategoryTheory.Adjunction.toComonad
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a comonad on
the category `D`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps coe ε δ]
def toComonad (h : L ⊣ R) : Comonad D 
goal: CategoryTheory.Comonad D

full_name: CategoryTheory.Adjunction.toComonad_coe
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a comonad on
the category `D`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps coe ε δ]
def toComonad (h : L ⊣ R) : Comonad D 
goal: h.toComonad.toFunctor = R.comp L

full_name: CategoryTheory.Adjunction.toComonad_ε
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a comonad on
the category `D`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps coe ε δ]
def toComonad (h : L ⊣ R) : Comonad D 
goal: h.toComonad.ε = h.counit

full_name: CategoryTheory.Adjunction.toComonad_δ
code: /-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a comonad on
the category `D`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps coe ε δ]
def toComonad (h : L ⊣ R) : Comonad D 
goal: h.toComonad.δ = CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft R h.unit) L

full_name: CategoryTheory.Adjunction.adjToMonadIso_hom_toNatTrans_app
code: /-- The monad induced by the Eilenberg-Moore adjunction is the original monad.  -/
@[simps!]
def adjToMonadIso (T : Monad C) : T.adj.toMonad ≅ T 
goal: (CategoryTheory.Adjunction.adjToMonadIso T).hom.app X = CategoryTheory.CategoryStruct.id (T.obj X)

full_name: CategoryTheory.Adjunction.adjToMonadIso_inv_toNatTrans_app
code: /-- The monad induced by the Eilenberg-Moore adjunction is the original monad.  -/
@[simps!]
def adjToMonadIso (T : Monad C) : T.adj.toMonad ≅ T 
goal: (CategoryTheory.Adjunction.adjToMonadIso T).inv.app X = CategoryTheory.CategoryStruct.id (T.obj X)

full_name: CategoryTheory.Adjunction.adjToMonadIso
code: /-- The monad induced by the Eilenberg-Moore adjunction is the original monad.  -/
@[simps!]
def adjToMonadIso (T : Monad C) : T.adj.toMonad ≅ T 
goal: T.adj.toMonad ≅ T

full_name: CategoryTheory.Adjunction.adjToComonadIso
code: /-- The comonad induced by the Eilenberg-Moore adjunction is the original comonad. -/
@[simps!]
def adjToComonadIso (G : Comonad C) : G.adj.toComonad ≅ G 
goal: G.adj.toComonad ≅ G

full_name: CategoryTheory.Adjunction.adjToComonadIso_hom_toNatTrans_app
code: /-- The comonad induced by the Eilenberg-Moore adjunction is the original comonad. -/
@[simps!]
def adjToComonadIso (G : Comonad C) : G.adj.toComonad ≅ G 
goal: (CategoryTheory.Adjunction.adjToComonadIso G).hom.app X = CategoryTheory.CategoryStruct.id (G.obj X)

full_name: CategoryTheory.Adjunction.adjToComonadIso_inv_toNatTrans_app
code: /-- The comonad induced by the Eilenberg-Moore adjunction is the original comonad. -/
@[simps!]
def adjToComonadIso (G : Comonad C) : G.adj.toComonad ≅ G 
goal: (CategoryTheory.Adjunction.adjToComonadIso G).inv.app X = CategoryTheory.CategoryStruct.id (G.obj X)

full_name: CategoryTheory.Adjunction.unitAsIsoOfIso
code: /--
Given an adjunction `L ⊣ R`, if `L ⋙ R` is abstractly isomorphic to the identity functor, then the
unit is an isomorphism.
-/
def unitAsIsoOfIso (adj : L ⊣ R) (i : L ⋙ R ≅ 𝟭 C) : 𝟭 C ≅ L ⋙ R 
goal: CategoryTheory.Functor.id C ≅ L.comp R

full_name: CategoryTheory.Adjunction.isIso_unit_of_iso
code: lemma isIso_unit_of_iso  (adj : L ⊣ R) (i : L ⋙ R ≅ 𝟭 C) : IsIso adj.unit 
goal: CategoryTheory.IsIso adj.unit

full_name: CategoryTheory.Adjunction.fullyFaithfulLOfCompIsoId
code: /--
Given an adjunction `L ⊣ R`, if `L ⋙ R` is isomorphic to the identity functor, then `L` is
fully faithful.
-/
noncomputable def fullyFaithfulLOfCompIsoId (adj : L ⊣ R) (i : L ⋙ R ≅ 𝟭 C) : L.FullyFaithful 
goal: L.FullyFaithful

full_name: CategoryTheory.Adjunction.counitAsIsoOfIso
code: /--
Given an adjunction `L ⊣ R`, if `R ⋙ L` is abstractly isomorphic to the identity functor, then the
counit is an isomorphism.
-/
def counitAsIsoOfIso (adj : L ⊣ R) (j : R ⋙ L ≅ 𝟭 D) : R ⋙ L ≅ 𝟭 D 
goal: R.comp L ≅ CategoryTheory.Functor.id D

full_name: CategoryTheory.Adjunction.isIso_counit_of_iso
code: lemma isIso_counit_of_iso (adj : L ⊣ R) (j : R ⋙ L ≅ 𝟭 D) : IsIso adj.counit 
goal: CategoryTheory.IsIso adj.counit

full_name: CategoryTheory.Adjunction.fullyFaithfulROfCompIsoId
code: /--
Given an adjunction `L ⊣ R`, if `R ⋙ L` is isomorphic to the identity functor, then `R` is
fully faithful.
-/
noncomputable def fullyFaithfulROfCompIsoId (adj : L ⊣ R) (j : R ⋙ L ≅ 𝟭 D) : R.FullyFaithful 
goal: R.FullyFaithful

full_name: CategoryTheory.Monad.comparison_obj_a
code: /-- Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Monad.comparison R`
sending objects `Y : D` to Eilenberg-Moore algebras for `L ⋙ R` with underlying object `R.obj X`.

We later show that this is full when `R` is full, faithful when `R` is faithful,
and essentially surjective when `R` is reflective.
-/
@[simps]
def Monad.comparison (h : L ⊣ R) : D ⥤ h.toMonad.Algebra 
goal: ((CategoryTheory.Monad.comparison h).obj X).a = R.map (h.counit.app X)

full_name: CategoryTheory.Monad.comparison_obj_A
code: /-- Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Monad.comparison R`
sending objects `Y : D` to Eilenberg-Moore algebras for `L ⋙ R` with underlying object `R.obj X`.

We later show that this is full when `R` is full, faithful when `R` is faithful,
and essentially surjective when `R` is reflective.
-/
@[simps]
def Monad.comparison (h : L ⊣ R) : D ⥤ h.toMonad.Algebra 
goal: ((CategoryTheory.Monad.comparison h).obj X).A = R.obj X

full_name: CategoryTheory.Monad.comparison_map_f
code: /-- Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Monad.comparison R`
sending objects `Y : D` to Eilenberg-Moore algebras for `L ⋙ R` with underlying object `R.obj X`.

We later show that this is full when `R` is full, faithful when `R` is faithful,
and essentially surjective when `R` is reflective.
-/
@[simps]
def Monad.comparison (h : L ⊣ R) : D ⥤ h.toMonad.Algebra 
goal: ∀ {X Y : D} (f : X ⟶ Y), ((CategoryTheory.Monad.comparison h).map f).f = R.map f

full_name: CategoryTheory.Monad.comparison
code: /-- Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Monad.comparison R`
sending objects `Y : D` to Eilenberg-Moore algebras for `L ⋙ R` with underlying object `R.obj X`.

We later show that this is full when `R` is full, faithful when `R` is faithful,
and essentially surjective when `R` is reflective.
-/
@[simps]
def Monad.comparison (h : L ⊣ R) : D ⥤ h.toMonad.Algebra 
goal: CategoryTheory.Functor D h.toMonad.Algebra

full_name: CategoryTheory.Monad.comparisonForget
code: /-- The underlying object of `(Monad.comparison R).obj X` is just `R.obj X`.
-/
@[simps]
def Monad.comparisonForget (h : L ⊣ R) : Monad.comparison h ⋙ h.toMonad.forget ≅ R 
goal: (CategoryTheory.Monad.comparison h).comp h.toMonad.forget ≅ R

full_name: CategoryTheory.Monad.comparisonForget_hom_app
code: /-- The underlying object of `(Monad.comparison R).obj X` is just `R.obj X`.
-/
@[simps]
def Monad.comparisonForget (h : L ⊣ R) : Monad.comparison h ⋙ h.toMonad.forget ≅ R 
goal: (CategoryTheory.Monad.comparisonForget h).hom.app X =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Monad.comparison h).comp h.toMonad.forget).obj X)

full_name: CategoryTheory.Monad.comparisonForget_inv_app
code: /-- The underlying object of `(Monad.comparison R).obj X` is just `R.obj X`.
-/
@[simps]
def Monad.comparisonForget (h : L ⊣ R) : Monad.comparison h ⋙ h.toMonad.forget ≅ R 
goal: (CategoryTheory.Monad.comparisonForget h).inv.app X = CategoryTheory.CategoryStruct.id (R.obj X)

full_name: CategoryTheory.Monad.left_comparison
code: theorem Monad.left_comparison (h : L ⊣ R) : L ⋙ Monad.comparison h = h.toMonad.free 
goal: L.comp (CategoryTheory.Monad.comparison h) = h.toMonad.free

full_name: CategoryTheory.instFaithfulAlgebraToMonadComparison
code: instance [R.Faithful] (h : L ⊣ R) : (Monad.comparison h).Faithful 
goal: (CategoryTheory.Monad.comparison h).Faithful

full_name: CategoryTheory.instFullAlgebraToMonadAdjComparison
code: instance (T : Monad C) : (Monad.comparison T.adj).Full 
goal: (CategoryTheory.Monad.comparison T.adj).Full

full_name: CategoryTheory.instEssSurjAlgebraToMonadAdjComparison
code: instance (T : Monad C) : (Monad.comparison T.adj).EssSurj 
goal: (CategoryTheory.Monad.comparison T.adj).EssSurj

full_name: CategoryTheory.Comonad.comparison_map_f
code: /--
Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Comonad.comparison L`
sending objects `X : C` to Eilenberg-Moore coalgebras for `L ⋙ R` with underlying object
`L.obj X`.
-/
@[simps]
def Comonad.comparison (h : L ⊣ R) : C ⥤ h.toComonad.Coalgebra 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Comonad.comparison h).map f).f = L.map f

full_name: CategoryTheory.Comonad.comparison_obj_a
code: /--
Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Comonad.comparison L`
sending objects `X : C` to Eilenberg-Moore coalgebras for `L ⋙ R` with underlying object
`L.obj X`.
-/
@[simps]
def Comonad.comparison (h : L ⊣ R) : C ⥤ h.toComonad.Coalgebra 
goal: ((CategoryTheory.Comonad.comparison h).obj X).a = L.map (h.unit.app X)

full_name: CategoryTheory.Comonad.comparison_obj_A
code: /--
Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Comonad.comparison L`
sending objects `X : C` to Eilenberg-Moore coalgebras for `L ⋙ R` with underlying object
`L.obj X`.
-/
@[simps]
def Comonad.comparison (h : L ⊣ R) : C ⥤ h.toComonad.Coalgebra 
goal: ((CategoryTheory.Comonad.comparison h).obj X).A = L.obj X

full_name: CategoryTheory.Comonad.comparison
code: /--
Given any adjunction `L ⊣ R`, there is a comparison functor `CategoryTheory.Comonad.comparison L`
sending objects `X : C` to Eilenberg-Moore coalgebras for `L ⋙ R` with underlying object
`L.obj X`.
-/
@[simps]
def Comonad.comparison (h : L ⊣ R) : C ⥤ h.toComonad.Coalgebra 
goal: CategoryTheory.Functor C h.toComonad.Coalgebra

full_name: CategoryTheory.Comonad.comparisonForget_inv_app
code: /-- The underlying object of `(Comonad.comparison L).obj X` is just `L.obj X`.
-/
@[simps]
def Comonad.comparisonForget {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) :
    Comonad.comparison h ⋙ h.toComonad.forget ≅ L 
goal: (CategoryTheory.Comonad.comparisonForget h).inv.app X = CategoryTheory.CategoryStruct.id (L.obj X)

full_name: CategoryTheory.Comonad.comparisonForget
code: /-- The underlying object of `(Comonad.comparison L).obj X` is just `L.obj X`.
-/
@[simps]
def Comonad.comparisonForget {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) :
    Comonad.comparison h ⋙ h.toComonad.forget ≅ L 
goal: (CategoryTheory.Comonad.comparison h).comp h.toComonad.forget ≅ L

full_name: CategoryTheory.Comonad.comparisonForget_hom_app
code: /-- The underlying object of `(Comonad.comparison L).obj X` is just `L.obj X`.
-/
@[simps]
def Comonad.comparisonForget {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) :
    Comonad.comparison h ⋙ h.toComonad.forget ≅ L 
goal: (CategoryTheory.Comonad.comparisonForget h).hom.app X =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Comonad.comparison h).comp h.toComonad.forget).obj X)

full_name: CategoryTheory.Comonad.left_comparison
code: theorem Comonad.left_comparison (h : L ⊣ R) : R ⋙ Comonad.comparison h = h.toComonad.cofree 
goal: R.comp (CategoryTheory.Comonad.comparison h) = h.toComonad.cofree

full_name: CategoryTheory.Comonad.comparison_faithful_of_faithful
code: instance Comonad.comparison_faithful_of_faithful [L.Faithful] (h : L ⊣ R) :
    (Comonad.comparison h).Faithful 
goal: (CategoryTheory.Comonad.comparison h).Faithful

full_name: CategoryTheory.instFullCoalgebraToComonadAdjComparison
code: instance (G : Comonad C) : (Comonad.comparison G.adj).Full 
goal: (CategoryTheory.Comonad.comparison G.adj).Full

full_name: CategoryTheory.instEssSurjCoalgebraToComonadAdjComparison
code: instance (G : Comonad C) : (Comonad.comparison G.adj).EssSurj 
goal: (CategoryTheory.Comonad.comparison G.adj).EssSurj

full_name: CategoryTheory.MonadicRightAdjoint
code: /-- A right adjoint functor `R : D ⥤ C` is *monadic* if the comparison functor `Monad.comparison R`
from `D` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class MonadicRightAdjoint (R : D ⥤ C) where
  /-- a choice of left adjoint for `R` -/
  L : C ⥤ D
  /-- `R` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Monad.comparison adj).IsEquivalence
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.MonadicRightAdjoint.L
code: /-- A right adjoint functor `R : D ⥤ C` is *monadic* if the comparison functor `Monad.comparison R`
from `D` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class MonadicRightAdjoint (R : D ⥤ C) where
  /-- a choice of left adjoint for `R` -/
  L : C ⥤ D
  /-- `R` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Monad.comparison adj).IsEquivalence
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.MonadicRightAdjoint.adj
code: /-- A right adjoint functor `R : D ⥤ C` is *monadic* if the comparison functor `Monad.comparison R`
from `D` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class MonadicRightAdjoint (R : D ⥤ C) where
  /-- a choice of left adjoint for `R` -/
  L : C ⥤ D
  /-- `R` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Monad.comparison adj).IsEquivalence
goal: CategoryTheory.MonadicRightAdjoint.L R ⊣ R

full_name: CategoryTheory.MonadicRightAdjoint.eqv
code: /-- A right adjoint functor `R : D ⥤ C` is *monadic* if the comparison functor `Monad.comparison R`
from `D` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class MonadicRightAdjoint (R : D ⥤ C) where
  /-- a choice of left adjoint for `R` -/
  L : C ⥤ D
  /-- `R` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Monad.comparison adj).IsEquivalence
goal: (CategoryTheory.Monad.comparison CategoryTheory.MonadicRightAdjoint.adj).IsEquivalence

full_name: CategoryTheory.monadicLeftAdjoint
code: /-- The left adjoint functor to `R` given by `[MonadicRightAdjoint R]`. -/
def monadicLeftAdjoint (R : D ⥤ C) [MonadicRightAdjoint R] : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.monadicAdjunction
code: /-- The adjunction `monadicLeftAdjoint R ⊣ R` given by `[MonadicRightAdjoint R]`. -/
def monadicAdjunction (R : D ⥤ C) [MonadicRightAdjoint R] :
    monadicLeftAdjoint R ⊣ R 
goal: CategoryTheory.monadicLeftAdjoint R ⊣ R

full_name: CategoryTheory.instIsEquivalenceAlgebraToMonadMonadicAdjunctionComparison
code: instance (R : D ⥤ C) [MonadicRightAdjoint R] :
    (Monad.comparison (monadicAdjunction R)).IsEquivalence 
goal: (CategoryTheory.Monad.comparison (CategoryTheory.monadicAdjunction R)).IsEquivalence

full_name: CategoryTheory.instIsRightAdjointOfMonadicRightAdjoint
code: instance (R : D ⥤ C) [MonadicRightAdjoint R] : R.IsRightAdjoint 
goal: R.IsRightAdjoint

full_name: CategoryTheory.instMonadicRightAdjointAlgebraForget
code: noncomputable instance (T : Monad C) : MonadicRightAdjoint T.forget 
goal: CategoryTheory.MonadicRightAdjoint T.forget

full_name: CategoryTheory.ComonadicLeftAdjoint
code: /--
A left adjoint functor `L : C ⥤ D` is *comonadic* if the comparison functor `Comonad.comparison L`
from `C` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class ComonadicLeftAdjoint (L : C ⥤ D) where
  /-- a choice of right adjoint for `L` -/
  R : D ⥤ C
  /-- `L` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Comonad.comparison adj).IsEquivalence
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.ComonadicLeftAdjoint.R
code: /--
A left adjoint functor `L : C ⥤ D` is *comonadic* if the comparison functor `Comonad.comparison L`
from `C` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class ComonadicLeftAdjoint (L : C ⥤ D) where
  /-- a choice of right adjoint for `L` -/
  R : D ⥤ C
  /-- `L` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Comonad.comparison adj).IsEquivalence
goal: CategoryTheory.Functor D C

full_name: CategoryTheory.ComonadicLeftAdjoint.adj
code: /--
A left adjoint functor `L : C ⥤ D` is *comonadic* if the comparison functor `Comonad.comparison L`
from `C` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class ComonadicLeftAdjoint (L : C ⥤ D) where
  /-- a choice of right adjoint for `L` -/
  R : D ⥤ C
  /-- `L` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Comonad.comparison adj).IsEquivalence
goal: L ⊣ CategoryTheory.ComonadicLeftAdjoint.R L

full_name: CategoryTheory.ComonadicLeftAdjoint.eqv
code: /--
A left adjoint functor `L : C ⥤ D` is *comonadic* if the comparison functor `Comonad.comparison L`
from `C` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class ComonadicLeftAdjoint (L : C ⥤ D) where
  /-- a choice of right adjoint for `L` -/
  R : D ⥤ C
  /-- `L` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Comonad.comparison adj).IsEquivalence
goal: (CategoryTheory.Comonad.comparison CategoryTheory.ComonadicLeftAdjoint.adj).IsEquivalence

full_name: CategoryTheory.comonadicRightAdjoint
code: /-- The right adjoint functor to `L` given by `[ComonadicLeftAdjoint L]`. -/
def comonadicRightAdjoint (L : C ⥤ D) [ComonadicLeftAdjoint L] : D ⥤ C 
goal: CategoryTheory.Functor D C

full_name: CategoryTheory.comonadicAdjunction
code: /-- The adjunction `L ⊣ comonadicRightAdjoint L` given by `[ComonadicLeftAdjoint L]`. -/
def comonadicAdjunction (L : C ⥤ D) [ComonadicLeftAdjoint L] :
    L ⊣ comonadicRightAdjoint L 
goal: L ⊣ CategoryTheory.comonadicRightAdjoint L

full_name: CategoryTheory.instIsEquivalenceCoalgebraToComonadComonadicAdjunctionComparison
code: instance (L : C ⥤ D) [ComonadicLeftAdjoint L] :
    (Comonad.comparison (comonadicAdjunction L)).IsEquivalence 
goal: (CategoryTheory.Comonad.comparison (CategoryTheory.comonadicAdjunction L)).IsEquivalence

full_name: CategoryTheory.instIsLeftAdjointOfComonadicLeftAdjoint
code: instance (L : C ⥤ D) [ComonadicLeftAdjoint L] : L.IsLeftAdjoint 
goal: L.IsLeftAdjoint

full_name: CategoryTheory.instComonadicLeftAdjointCoalgebraForget
code: noncomputable instance (G : Comonad C) : ComonadicLeftAdjoint G.forget 
goal: CategoryTheory.ComonadicLeftAdjoint G.forget

full_name: CategoryTheory.μ_iso_of_reflective
code: instance μ_iso_of_reflective [Reflective R] : IsIso (reflectorAdjunction R).toMonad.μ 
goal: CategoryTheory.IsIso (CategoryTheory.reflectorAdjunction R).toMonad.μ

full_name: CategoryTheory.δ_iso_of_coreflective
code: instance δ_iso_of_coreflective [Coreflective R] : IsIso (coreflectorAdjunction R).toComonad.δ 
goal: CategoryTheory.IsIso (CategoryTheory.coreflectorAdjunction R).toComonad.δ

full_name: CategoryTheory.Reflective.instIsIsoAppUnitReflectorAdjunctionA
code: instance [Reflective R] (X : (reflectorAdjunction R).toMonad.Algebra) :
    IsIso ((reflectorAdjunction R).unit.app X.A) 
goal: CategoryTheory.IsIso ((CategoryTheory.reflectorAdjunction R).unit.app X.A)

full_name: CategoryTheory.Reflective.comparison_essSurj
code: instance comparison_essSurj [Reflective R] :
    (Monad.comparison (reflectorAdjunction R)).EssSurj 
goal: (CategoryTheory.Monad.comparison (CategoryTheory.reflectorAdjunction R)).EssSurj

full_name: CategoryTheory.Reflective.comparison_full
code: lemma comparison_full [R.Full] {L : C ⥤ D} (adj : L ⊣ R) :
    (Monad.comparison adj).Full 
goal: (CategoryTheory.Monad.comparison adj).Full

full_name: CategoryTheory.Coreflective.instIsIsoAppCounitCoreflectorAdjunctionA
code: instance [Coreflective R] (X : (coreflectorAdjunction R).toComonad.Coalgebra) :
    IsIso ((coreflectorAdjunction R).counit.app X.A) 
goal: CategoryTheory.IsIso ((CategoryTheory.coreflectorAdjunction R).counit.app X.A)

full_name: CategoryTheory.Coreflective.comparison_essSurj
code: instance comparison_essSurj [Coreflective R] :
    (Comonad.comparison (coreflectorAdjunction R)).EssSurj 
goal: (CategoryTheory.Comonad.comparison (CategoryTheory.coreflectorAdjunction R)).EssSurj

full_name: CategoryTheory.Coreflective.comparison_full
code: lemma comparison_full [R.Full] {L : C ⥤ D} (adj : R ⊣ L) :
    (Comonad.comparison adj).Full 
goal: (CategoryTheory.Comonad.comparison adj).Full

full_name: CategoryTheory.monadicOfReflective
code: /-- Any reflective inclusion has a monadic right adjoint.
    cf Prop 5.3.3 of [Riehl][riehl2017] -/
instance (priority := 100) monadicOfReflective [Reflective R] :
    MonadicRightAdjoint R 
goal: CategoryTheory.MonadicRightAdjoint R

full_name: CategoryTheory.comonadicOfCoreflective
code: /-- Any coreflective inclusion has a comonadic left adjoint.
    cf Dual statement of Prop 5.3.3 of [Riehl][riehl2017] -/
instance (priority := 100) comonadicOfCoreflective [Coreflective R] :
    ComonadicLeftAdjoint R 
goal: CategoryTheory.ComonadicLeftAdjoint R