File: Mathlib/CategoryTheory/Monad/Monadicity.lean

full_name: CategoryTheory.Monad.MonadicityInternal.main_pair_reflexive
code: /-- The "main pair" for an algebra `(A, α)` is the pair of morphisms `(F α, ε_FA)`. It is always a
reflexive pair, and will be used to construct the left adjoint to the comparison functor and show it
is an equivalence.
-/
instance main_pair_reflexive (A : adj.toMonad.Algebra) :
    IsReflexivePair (F.map A.a) (adj.counit.app (F.obj A.A)) 
goal: CategoryTheory.IsReflexivePair (F.map A.a) (adj.counit.app (F.obj A.A))

full_name: CategoryTheory.Monad.MonadicityInternal.main_pair_G_split
code: /-- The "main pair" for an algebra `(A, α)` is the pair of morphisms `(F α, ε_FA)`. It is always a
`G`-split pair, and will be used to construct the left adjoint to the comparison functor and show it
is an equivalence.
-/
instance main_pair_G_split (A : adj.toMonad.Algebra) :
    G.IsSplitPair (F.map A.a)
      (adj.counit.app (F.obj A.A)) 
goal: G.IsSplitPair (F.map A.a) (adj.counit.app (F.obj A.A))

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointObj
code: /-- The object function for the left adjoint to the comparison functor. -/
def comparisonLeftAdjointObj (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app _)] : D 
goal: D

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv_apply_f
code: /--
We have a bijection of homsets which will be used to construct the left adjoint to the comparison
functor.
-/
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B) 
goal: ∀ (a : CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointObj adj A ⟶ B),
  ((CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv adj A B) a).f =
    CategoryTheory.CategoryStruct.comp (adj.unit.app A.A)
      (G.map
        ↑((CategoryTheory.Limits.Cofork.IsColimit.homIso
              (CategoryTheory.Limits.colimit.isColimit
                (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))))
              B)
            a))

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv
code: /--
We have a bijection of homsets which will be used to construct the left adjoint to the comparison
functor.
-/
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B) 
goal: (CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointObj adj A ⟶ B) ≃
  (A ⟶ (CategoryTheory.Monad.comparison adj).obj B)

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv_symm_apply
code: /--
We have a bijection of homsets which will be used to construct the left adjoint to the comparison
functor.
-/
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B) 
goal: ∀ (a : A ⟶ (CategoryTheory.Monad.comparison adj).obj B),
  (CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv adj A B).symm a =
    (CategoryTheory.Limits.Cofork.IsColimit.homIso
          (CategoryTheory.Limits.colimit.isColimit
            (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))))
          B).symm
      ⟨CategoryTheory.CategoryStruct.comp (F.map a.f) (adj.counit.app B), ⋯⟩

full_name: CategoryTheory.Monad.MonadicityInternal.leftAdjointComparison
code: /-- Construct the adjunction to the comparison functor.
-/
def leftAdjointComparison
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))] :
    adj.toMonad.Algebra ⥤ D 
goal: CategoryTheory.Functor adj.toMonad.Algebra D

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction
code: /-- Provided we have the appropriate coequalizers, we have an adjunction to the comparison functor.
-/
@[simps! counit]
def comparisonAdjunction
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))] :
    leftAdjointComparison adj ⊣ comparison adj 
goal: CategoryTheory.Monad.MonadicityInternal.leftAdjointComparison adj ⊣ CategoryTheory.Monad.comparison adj

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit
code: /-- Provided we have the appropriate coequalizers, we have an adjunction to the comparison functor.
-/
@[simps! counit]
def comparisonAdjunction
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))] :
    leftAdjointComparison adj ⊣ comparison adj 
goal: (CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).counit =
  {
    app := fun Y =>
      (CategoryTheory.Limits.Cofork.IsColimit.homIso
            (CategoryTheory.Limits.colimit.isColimit
              (CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app Y)))
                (adj.counit.app (F.obj (G.obj Y)))))
            Y).symm
        ⟨adj.counit.app Y, ⋯⟩,
    naturality := ⋯ }

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_unit_f_aux
code: theorem comparisonAdjunction_unit_f_aux
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))]
    (A : adj.toMonad.Algebra) :
    ((comparisonAdjunction adj).unit.app A).f =
      adj.homEquiv A.A _
        (coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A))) 
goal: ((CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).unit.app A).f =
  (adj.homEquiv A.A (CategoryTheory.Limits.coequalizer (F.map A.a) (adj.counit.app (F.obj A.A))))
    (CategoryTheory.Limits.coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A)))

full_name: CategoryTheory.Monad.MonadicityInternal.unitCofork_pt
code: /-- This is a cofork which is helpful for establishing monadicity: the morphism from the Beck
coequalizer to this cofork is the unit for the adjunction on the comparison functor.
-/
@[simps! pt]
def unitCofork (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    Cofork (G.map (F.map A.a)) (G.map (adj.counit.app (F.obj A.A))) 
goal: (CategoryTheory.Monad.MonadicityInternal.unitCofork A).pt =
  G.obj (CategoryTheory.Limits.coequalizer (F.map A.a) (adj.counit.app (F.obj A.A)))

full_name: CategoryTheory.Monad.MonadicityInternal.unitCofork
code: /-- This is a cofork which is helpful for establishing monadicity: the morphism from the Beck
coequalizer to this cofork is the unit for the adjunction on the comparison functor.
-/
@[simps! pt]
def unitCofork (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    Cofork (G.map (F.map A.a)) (G.map (adj.counit.app (F.obj A.A))) 
goal: CategoryTheory.Limits.Cofork (G.map (F.map A.a)) (G.map (adj.counit.app (F.obj A.A)))

full_name: CategoryTheory.Monad.MonadicityInternal.unitCofork_π
code: @[simp]
theorem unitCofork_π (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (unitCofork A).π = G.map (coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A))) 
goal: (CategoryTheory.Monad.MonadicityInternal.unitCofork A).π =
  G.map (CategoryTheory.Limits.coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A)))

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_unit_f
code: theorem comparisonAdjunction_unit_f
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))]
    (A : adj.toMonad.Algebra) :
    ((comparisonAdjunction adj).unit.app A).f = (beckCoequalizer A).desc (unitCofork A) 
goal: ((CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).unit.app A).f =
  (CategoryTheory.Monad.beckCoequalizer A).desc (CategoryTheory.Monad.MonadicityInternal.unitCofork A)

full_name: CategoryTheory.Monad.MonadicityInternal.counitCofork
code: /-- The cofork which describes the counit of the adjunction: the morphism from the coequalizer of
this pair to this morphism is the counit.
-/
@[simps!]
def counitCofork (B : D) :
    Cofork (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B))) 
goal: CategoryTheory.Limits.Cofork (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B)))

full_name: CategoryTheory.Monad.MonadicityInternal.counitCofork_pt
code: /-- The cofork which describes the counit of the adjunction: the morphism from the coequalizer of
this pair to this morphism is the counit.
-/
@[simps!]
def counitCofork (B : D) :
    Cofork (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B))) 
goal: (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B).pt = B

full_name: CategoryTheory.Monad.MonadicityInternal.counitCofork_ι_app
code: /-- The cofork which describes the counit of the adjunction: the morphism from the coequalizer of
this pair to this morphism is the counit.
-/
@[simps!]
def counitCofork (B : D) :
    Cofork (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B))) 
goal: (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B).ι.app X =
  CategoryTheory.Limits.WalkingParallelPair.rec
    (CategoryTheory.CategoryStruct.comp (adj.counit.app (F.obj (G.obj B))) (adj.counit.app B)) (adj.counit.app B) X

full_name: CategoryTheory.Monad.MonadicityInternal.unitColimitOfPreservesCoequalizer
code: /-- The unit cofork is a colimit provided `G` preserves it.  -/
def unitColimitOfPreservesCoequalizer (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
    [PreservesColimit (parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))) G] :
    IsColimit (unitCofork (G := G) A) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Monad.MonadicityInternal.unitCofork A)

full_name: CategoryTheory.Monad.MonadicityInternal.counitCoequalizerOfReflectsCoequalizer
code: /-- The counit cofork is a colimit provided `G` reflects it. -/
def counitCoequalizerOfReflectsCoequalizer (B : D)
    [ReflectsColimit (parallelPair (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B)))) G] :
    IsColimit (counitCofork (adj := adj) B) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B)

full_name: CategoryTheory.Monad.MonadicityInternal.instHasColimitWalkingParallelPairParallelPairMapAppCounitObjOfHasCoequalizerAA
code: instance
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
    (B : D) : HasColimit (parallelPair
      (F.map (G.map (NatTrans.app adj.counit B)))
      (NatTrans.app adj.counit (F.obj (G.obj B)))) 
goal: CategoryTheory.Limits.HasColimit
  (CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))

full_name: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit_app
code: theorem comparisonAdjunction_counit_app
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D) :
    (comparisonAdjunction adj).counit.app B = colimit.desc _ (counitCofork adj B) 
goal: (CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).counit.app B =
  CategoryTheory.Limits.colimit.desc
    (CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
    (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B)

full_name: CategoryTheory.Monad.createsGSplitCoequalizersOfMonadic
code: /--
If `G` is monadic, it creates colimits of `G`-split pairs. This is the "boring" direction of Beck's
monadicity theorem, the converse is given in `monadicOfCreatesGSplitCoequalizers`.
-/
def createsGSplitCoequalizersOfMonadic [MonadicRightAdjoint G] ⦃A B⦄ (f g : A ⟶ B)
    [G.IsSplitPair f g] : CreatesColimit (parallelPair f g) G 
goal: CategoryTheory.CreatesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.HasCoequalizerOfIsSplitPair.out
code: class HasCoequalizerOfIsSplitPair (G : D ⥤ C) : Prop where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], HasCoequalizer f g
goal: CategoryTheory.Limits.HasCoequalizer f g

full_name: CategoryTheory.Monad.HasCoequalizerOfIsSplitPair
code: class HasCoequalizerOfIsSplitPair (G : D ⥤ C) : Prop where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], HasCoequalizer f g
goal: Prop

full_name: CategoryTheory.Monad.instHasCoequalizerMapAAppCounitObjAOfHasCoequalizerOfIsSplitPair
code: instance [HasCoequalizerOfIsSplitPair G] : ∀ (A : Algebra adj.toMonad),
    HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A)) 
goal: CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))

full_name: CategoryTheory.Monad.PreservesColimitOfIsSplitPair.out
code: class PreservesColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], PreservesColimit (parallelPair f g) G
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.PreservesColimitOfIsSplitPair
code: class PreservesColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], PreservesColimit (parallelPair f g) G
goal: Type (max (max u₁ u₂) v₁)

full_name: CategoryTheory.Monad.instPreservesColimitWalkingParallelPairParallelPairOfIsSplitPairOfPreservesColimitOfIsSplitPair
code: instance {A B} (f g : A ⟶ B) [G.IsSplitPair f g] [PreservesColimitOfIsSplitPair G] :
    PreservesColimit (parallelPair f g) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instPreservesColimitWalkingParallelPairParallelPairMapAAppCounitObjAOfPreservesColimitOfIsSplitPair
code: instance [PreservesColimitOfIsSplitPair G] : ∀ (A : Algebra adj.toMonad),
   PreservesColimit (parallelPair (F.map A.a)
      (NatTrans.app adj.counit (F.obj A.A))) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))) G

full_name: CategoryTheory.Monad.ReflectsColimitOfIsSplitPair.out
code: class ReflectsColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], ReflectsColimit (parallelPair f g) G
goal: CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.ReflectsColimitOfIsSplitPair
code: class ReflectsColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], ReflectsColimit (parallelPair f g) G
goal: Type (max (max u₁ u₂) v₁)

full_name: CategoryTheory.Monad.instReflectsColimitWalkingParallelPairParallelPairOfIsSplitPairOfReflectsColimitOfIsSplitPair
code: instance {A B} (f g : A ⟶ B) [G.IsSplitPair f g] [ReflectsColimitOfIsSplitPair G] :
    ReflectsColimit (parallelPair f g) G 
goal: CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instReflectsColimitWalkingParallelPairParallelPairMapAAppCounitObjAOfReflectsColimitOfIsSplitPair
code: instance [ReflectsColimitOfIsSplitPair G] : ∀ (A : Algebra adj.toMonad),
    ReflectsColimit (parallelPair (F.map A.a)
      (NatTrans.app adj.counit (F.obj A.A))) G 
goal: CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))) G

full_name: CategoryTheory.Monad.monadicOfHasPreservesReflectsGSplitCoequalizers
code: /-- To show `G` is a monadic right adjoint, we can show it preserves and reflects `G`-split
coequalizers, and `C` has them.
-/
def monadicOfHasPreservesReflectsGSplitCoequalizers [HasCoequalizerOfIsSplitPair G]
    [PreservesColimitOfIsSplitPair G] [ReflectsColimitOfIsSplitPair G] :
    MonadicRightAdjoint G 
goal: CategoryTheory.MonadicRightAdjoint G

full_name: CategoryTheory.Monad.CreatesColimitOfIsSplitPair
code: class CreatesColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], CreatesColimit (parallelPair f g) G
goal: Type (max (max u₁ u₂) v₁)

full_name: CategoryTheory.Monad.CreatesColimitOfIsSplitPair.out
code: class CreatesColimitOfIsSplitPair (G : D ⥤ C) where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], CreatesColimit (parallelPair f g) G
goal: CategoryTheory.CreatesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instCreatesColimitWalkingParallelPairParallelPairOfIsSplitPairOfCreatesColimitOfIsSplitPair
code: instance {A B} (f g : A ⟶ B) [G.IsSplitPair f g] [CreatesColimitOfIsSplitPair G] :
    CreatesColimit (parallelPair f g) G 
goal: CategoryTheory.CreatesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instCreatesColimitWalkingParallelPairParallelPairMapAAppCounitObjAOfCreatesColimitOfIsSplitPair
code: instance [CreatesColimitOfIsSplitPair G] : ∀ (A : Algebra adj.toMonad),
    CreatesColimit (parallelPair (F.map A.a)
      (NatTrans.app adj.counit (F.obj A.A))) G 
goal: CategoryTheory.CreatesColimit (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))) G

full_name: CategoryTheory.Monad.monadicOfCreatesGSplitCoequalizers
code: /--
Beck's monadicity theorem. If `G` has a right adjoint and creates coequalizers of `G`-split pairs,
then it is monadic.
This is the converse of `createsGSplitOfMonadic`.
-/
def monadicOfCreatesGSplitCoequalizers [CreatesColimitOfIsSplitPair G] :
    MonadicRightAdjoint G 
goal: CategoryTheory.MonadicRightAdjoint G

full_name: CategoryTheory.Monad.monadicOfHasPreservesGSplitCoequalizersOfReflectsIsomorphisms
code: /-- An alternate version of Beck's monadicity theorem. If `G` reflects isomorphisms, preserves
coequalizers of `G`-split pairs and `C` has coequalizers of `G`-split pairs, then it is monadic.
-/
def monadicOfHasPreservesGSplitCoequalizersOfReflectsIsomorphisms [G.ReflectsIsomorphisms]
    [HasCoequalizerOfIsSplitPair G] [PreservesColimitOfIsSplitPair G] :
    MonadicRightAdjoint G 
goal: CategoryTheory.MonadicRightAdjoint G

full_name: CategoryTheory.Monad.PreservesColimitOfIsReflexivePair
code: class PreservesColimitOfIsReflexivePair (G : C ⥤ D) where
  out : ∀ ⦃A B⦄ (f g : A ⟶ B) [IsReflexivePair f g], PreservesColimit (parallelPair f g) G
goal: Type (max (max u₁ u₂) v₁)

full_name: CategoryTheory.Monad.PreservesColimitOfIsReflexivePair.out
code: class PreservesColimitOfIsReflexivePair (G : C ⥤ D) where
  out : ∀ ⦃A B⦄ (f g : A ⟶ B) [IsReflexivePair f g], PreservesColimit (parallelPair f g) G
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instPreservesColimitWalkingParallelPairParallelPairOfIsReflexivePairOfPreservesColimitOfIsReflexivePair
code: instance {A B} (f g : A ⟶ B) [IsReflexivePair f g] [PreservesColimitOfIsReflexivePair G] :
  PreservesColimit (parallelPair f g) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G

full_name: CategoryTheory.Monad.instPreservesColimitWalkingParallelPairParallelPairMapAAppCounitObjAOfPreservesColimitOfIsReflexivePair
code: instance [PreservesColimitOfIsReflexivePair G] : ∀ X : Algebra adj.toMonad,
    PreservesColimit (parallelPair (F.map X.a)
      (NatTrans.app adj.counit (F.obj X.A))) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair (F.map X.a) (adj.counit.app (F.obj X.A))) G

full_name: CategoryTheory.Monad.monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms
code: /-- Reflexive (crude) monadicity theorem. If `G` has a right adjoint, `D` has and `G` preserves
reflexive coequalizers and `G` reflects isomorphisms, then `G` is monadic.
-/
def monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms : MonadicRightAdjoint G 
goal: CategoryTheory.MonadicRightAdjoint G