theorem comparisonAdjunction_counit_app
    [∀ A : (adj).toMonad.Algebra, HasCoequalizer ((F).map A.a) ((adj).counit.app ((F).obj A.A))]
    (B : D) : (comparisonAdjunction (G := G)).counit.app B = colimit.desc _ (counitCofork B) := by
  apply coequalizer.hom_ext
  change
    coequalizer.π _ _ ≫ coequalizer.desc (((adj).homEquiv _ B).symm (𝟙 _)) _ =
      coequalizer.π _ _ ≫ coequalizer.desc _ _
  

Proof state:
case h
C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₁, u₂} D
G : D ⥤ C
inst✝¹ : IsRightAdjoint G
inst✝ : ∀ (A : Algebra (Adjunction.toMonad adj)), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc ((Adjunction.homEquiv adj (G.obj B) B).symm (𝟙 (G.obj B)))
        (_ :
          F.map ((comparison adj).obj B).a ≫
              ↑((Equiv.subtypeEquiv (Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B))
                      (_ :
                        ∀ (f : F.obj ((comparison adj).obj B).A ⟶ (𝟭 D).obj B),
                          F.map ((comparison adj).obj B).a ≫ f = adj.counit.app (F.obj ((comparison adj).obj B).A) ≫ f ↔
                            G.map (F.map ((Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B)) f)) ≫
                                G.map (adj.counit.app ((𝟭 D).obj B)) =
                              ((comparison adj).obj B).a ≫
                                (Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B)) f)).symm
                  ({ toFun := fun g => Algebra.Hom.mk ↑g,
                        invFun := fun f =>
                          { val := f.f,
                            property :=
                              (_ :
                                (Adjunction.toMonad adj).toFunctor.map f.f ≫ ((comparison adj).obj ((𝟭 D).obj B)).a =
                                  ((comparison adj).obj B).a ≫ f.f) },
                        left_inv :=
                          (_ :
                            ∀
                              (g :
                                { g //
                                  G.map (F.map g) ≫ G.map (adj.counit.app ((𝟭 D).obj B)) =
                                    ((comparison adj).obj B).a ≫ g }),
                              (fun f =>
                                    { val := f.f,
                                      property :=
                                        (_ :
                                          (Adjunction.toMonad adj).toFunctor.map f.f ≫
                                              ((comparison adj).obj ((𝟭 D).obj B)).a =
                                            ((comparison adj).obj B).a ≫ f.f) })
                                  ((fun g => Algebra.Hom.mk ↑g) g) =
                                g),
                        right_inv :=
                          (_ :
                            ∀ (f : (comparison adj).obj B ⟶ (comparison adj).obj ((𝟭 D).obj B)),
                              (fun g => Algebra.Hom.mk ↑g)
                                  ((fun f =>
                                      { val := f.f,
                                        property :=
                                          (_ :
                                            (Adjunction.toMonad adj).toFunctor.map f.f ≫
                                                ((comparison adj).obj ((𝟭 D).obj B)).a =
                                              ((comparison adj).obj B).a ≫ f.f) })
                                    f) =
                                f) }.symm
                    (𝟙 ((comparison adj).obj B)))) =
            adj.counit.app (F.obj ((comparison adj).obj B).A) ≫
              ↑((Equiv.subtypeEquiv (Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B))
                      (_ :
                        ∀ (f : F.obj ((comparison adj).obj B).A ⟶ (𝟭 D).obj B),
                          F.map ((comparison adj).obj B).a ≫ f = adj.counit.app (F.obj ((comparison adj).obj B).A) ≫ f ↔
                            G.map (F.map ((Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B)) f)) ≫
                                G.map (adj.counit.app ((𝟭 D).obj B)) =
                              ((comparison adj).obj B).a ≫
                                (Adjunction.homEquiv adj ((comparison adj).obj B).A ((𝟭 D).obj B)) f)).symm
                  ({ toFun := fun g => Algebra.Hom.mk ↑g,
                        invFun := fun f =>
                          { val := f.f,
                            property :=
                              (_ :
                                (Adjunction.toMonad adj).toFunctor.map f.f ≫ ((comparison adj).obj ((𝟭 D).obj B)).a =
                                  ((comparison adj).obj B).a ≫ f.f) },
                        left_inv :=
                          (_ :
                            ∀
                              (g :
                                { g //
                                  G.map (F.map g) ≫ G.map (adj.counit.app ((𝟭 D).obj B)) =
                                    ((comparison adj).obj B).a ≫ g }),
                              (fun f =>
                                    { val := f.f,
                                      property :=
                                        (_ :
                                          (Adjunction.toMonad adj).toFunctor.map f.f ≫
                                              ((comparison adj).obj ((𝟭 D).obj B)).a =
                                            ((comparison adj).obj B).a ≫ f.f) })
                                  ((fun g => Algebra.Hom.mk ↑g) g) =
                                g),
                        right_inv :=
                          (_ :
                            ∀ (f : (comparison adj).obj B ⟶ (comparison adj).obj ((𝟭 D).obj B)),
                              (fun g => Algebra.Hom.mk ↑g)
                                  ((fun f =>
                                      { val := f.f,
                                        property :=
                                          (_ :
                                            (Adjunction.toMonad adj).toFunctor.map f.f ≫
                                                ((comparison adj).obj ((𝟭 D).obj B)).a =
                                              ((comparison adj).obj B).a ≫ f.f) })
                                    f) =
                                f) }.symm
                    (𝟙 ((comparison adj).obj B))))) =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc (adj.counit.app B)
        (_ :
          F.map (G.map (adj.counit.app B)) ≫ adj.counit.app ((𝟭 D).obj B) =
            adj.counit.app ((G ⋙ F).obj B) ≫ adj.counit.app B)

Next tactic:
simp