/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp] } }
  map f :=
    { hom := F.map f.hom
      comm := fun g => by dsimp; rw [← F.map_comp, f.comm, F.map_comp] }
  map_id M := by ext; simp only [Action.id_hom, F.map_id]
  map_comp f g := by ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
X✝ Y✝ Z✝ : Action V G
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({
            obj := fun M =>
              { V := F.obj M.V,
                ρ :=
                  { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                    map_mul' :=
                      (_ :
                        ∀ (g h : ↑G),
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              (g * h) =
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                              OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                h) } },
            map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.map
        (f ≫ g)).hom =
    ({
              obj := fun M =>
                { V := F.obj M.V,
                  ρ :=
                    { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                      map_mul' :=
                        (_ :
                          ∀ (g h : ↑G),
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                (g * h) =
                              OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  g *
                                OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  h) } },
              map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.map
          f ≫
        {
              obj := fun M =>
                { V := F.obj M.V,
                  ρ :=
                    { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                      map_mul' :=
                        (_ :
                          ∀ (g h : ↑G),
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                (g * h) =
                              OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  g *
                                OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  h) } },
              map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.map
          g).hom

Next tactic:
simp only [Action.comp_hom, F.map_comp]