/-- The equivalence `Mon_ (ModuleCat R) ≌ AlgebraCat R`
is naturally compatible with the forgetful functors to `ModuleCat R`.
-/
def monModuleEquivalenceAlgebraForget :
    MonModuleEquivalenceAlgebra.functor ⋙ forget₂ (AlgebraCat.{u} R) (ModuleCat.{u} R) ≅
      Mon_.forget (ModuleCat.{u} R) :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { toFun := _root_.id
            map_add' := fun x y => rfl
            map_smul' := fun c x => rfl }
        inv :=
          { toFun := _root_.id
            map_add' := fun x y => rfl
            map_smul' := fun c x => rfl } })
    (by 

Proof state:
R : Type u
inst✝ : CommRing R
⊢ ∀ {X Y : Mon_ (ModuleCat R)} (f : X ⟶ Y),
    (functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).map f ≫
        ((fun A =>
              Iso.mk
                {
                  toAddHom :=
                    { toFun := _root_.id,
                      map_add' :=
                        (_ :
                          ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                            _root_.id (x + y) = _root_.id (x + y)) },
                  map_smul' :=
                    (_ :
                      ∀ (c : R) (x : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                        AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x) =
                          AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x)) }
                {
                  toAddHom :=
                    { toFun := _root_.id,
                      map_add' :=
                        (_ : ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)), _root_.id (x + y) = _root_.id (x + y)) },
                  map_smul' :=
                    (_ :
                      ∀ (c : R) (x : ↑((Mon_.forget (ModuleCat R)).obj A)),
                        AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x) =
                          AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x)) })
            Y).hom =
      ((fun A =>
              Iso.mk
                {
                  toAddHom :=
                    { toFun := _root_.id,
                      map_add' :=
                        (_ :
                          ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                            _root_.id (x + y) = _root_.id (x + y)) },
                  map_smul' :=
                    (_ :
                      ∀ (c : R) (x : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                        AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x) =
                          AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((functor ⋙ forget₂ (AlgebraCat R) (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x)) }
                {
                  toAddHom :=
                    { toFun := _root_.id,
                      map_add' :=
                        (_ : ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)), _root_.id (x + y) = _root_.id (x + y)) },
                  map_smul' :=
                    (_ :
                      ∀ (c : R) (x : ↑((Mon_.forget (ModuleCat R)).obj A)),
                        AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x) =
                          AddHom.toFun
                            { toFun := _root_.id,
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑((Mon_.forget (ModuleCat R)).obj A)),
                                    _root_.id (x + y) = _root_.id (x + y)) }
                            (c • x)) })
            X).hom ≫
        (Mon_.forget (ModuleCat R)).map f

Next tactic:
aesop_cat