/-- 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 

Proof state:
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) =
    {
            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

Next tactic:
ext