l3lab/ntp-mathlib huggingface dataset:
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    

Proof state:
case hom.h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
x : (leftRegular G ⊗ X).V
⊢ (Hom.hom ((Hom.mk fun g => (g.1, X.ρ g.1⁻¹ g.2)) ≫ Hom.mk fun g => (g.1, X.ρ g.1 g.2)) x).2 =
    (Hom.hom (𝟙 (leftRegular G ⊗ X)) x).2

Next tactic:
change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    

Proof state:
case hom.h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
x : (leftRegular G ⊗ X).V
⊢ (X.ρ x.1 * X.ρ x.1⁻¹) x.2 = x.2

Next tactic:
rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
  inv_hom_id := by
    

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
⊢ ((Hom.mk fun g => (g.1, X.ρ g.1 g.2)) ≫ Hom.mk fun g => (g.1, X.ρ g.1⁻¹ g.2)) =
    𝟙 (leftRegular G ⊗ { V := X.V, ρ := 1 })

Next tactic:
apply Hom.ext
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
  inv_hom_id := by
    apply Hom.ext
    

Proof state:
case hom
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
⊢ ((Hom.mk fun g => (g.1, X.ρ g.1 g.2)) ≫ Hom.mk fun g => (g.1, X.ρ g.1⁻¹ g.2)).hom =
    (𝟙 (leftRegular G ⊗ { V := X.V, ρ := 1 })).hom

Next tactic:
funext x
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
  inv_hom_id := by
    apply Hom.ext
    funext x
    

Proof state:
case hom.h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
x : (leftRegular G ⊗ { V := X.V, ρ := 1 }).V
⊢ Hom.hom ((Hom.mk fun g => (g.1, X.ρ g.1 g.2)) ≫ Hom.mk fun g => (g.1, X.ρ g.1⁻¹ g.2)) x =
    Hom.hom (𝟙 (leftRegular G ⊗ { V := X.V, ρ := 1 })) x

Next tactic:
refine' Prod.ext rfl _
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
  inv_hom_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    

Proof state:
case hom.h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
x : (leftRegular G ⊗ { V := X.V, ρ := 1 }).V
⊢ (Hom.hom ((Hom.mk fun g => (g.1, X.ρ g.1 g.2)) ≫ Hom.mk fun g => (g.1, X.ρ g.1⁻¹ g.2)) x).2 =
    (Hom.hom (𝟙 (leftRegular G ⊗ { V := X.V, ρ := 1 })) x).2

Next tactic:
change (X.ρ (x.1⁻¹ : G) * X.ρ x.1) x.2 = x.2
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1 where
  hom :=
    { hom := fun g => ⟨g.1, (X.ρ (g.1⁻¹ : G) g.2 : X.V)⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = X.ρ _ _
        rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right] }
  inv :=
    { hom := fun g => ⟨g.1, X.ρ g.1 g.2⟩
      comm := fun (g : G) => by
        funext ⟨(x₁ : G), (x₂ : X.V)⟩
        refine' Prod.ext rfl _
        erw [tensor_rho, tensor_rho]
        dsimp
        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
        erw [leftRegular_ρ_apply]
        erw [map_mul]
        rfl }
  hom_inv_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ x.1 * X.ρ (x.1⁻¹ : G)) x.2 = x.2
    rw [← X.ρ.map_mul, mul_inv_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
  inv_hom_id := by
    apply Hom.ext
    funext x
    refine' Prod.ext rfl _
    change (X.ρ (x.1⁻¹ : G) * X.ρ x.1) x.2 = x.2
    

Proof state:
case hom.h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
x : (leftRegular G ⊗ { V := X.V, ρ := 1 }).V
⊢ (X.ρ x.1⁻¹ * X.ρ x.1) x.2 = x.2

Next tactic:
rw [← X.ρ.map_mul, inv_mul_self, X.ρ.map_one, MonCat.one_of, End.one_def, types_id_apply]
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
g : ↑G
⊢ (𝟙_ (Action W G)).ρ g ≫ F.ε = F.ε ≫ ((Functor.mapAction F.toFunctor G).obj (𝟙_ (Action V G))).ρ g

Next tactic:
dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
g : ↑G
⊢ 𝟙 (𝟙_ W) ≫ F.ε = F.ε ≫ F.map (𝟙 (𝟙_ V))

Next tactic:
rw [Category.id_comp, F.map_id, Category.comp_id]
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y X' Y' : Action V G
f : X ⟶ Y
g : X' ⟶ Y'
⊢ MonoidalCategory.tensorHom ((Functor.mapAction F.toFunctor G).map f) ((Functor.mapAction F.toFunctor G).map g) ≫
      (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) Y Y' =
    (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X X' ≫
      (Functor.mapAction F.toFunctor G).map (MonoidalCategory.tensorHom f g)

Next tactic:
ext
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y X' Y' : Action V G
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (MonoidalCategory.tensorHom ((Functor.mapAction F.toFunctor G).map f) ((Functor.mapAction F.toFunctor G).map g) ≫
        (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) Y Y').hom =
    ((fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X X' ≫
        (Functor.mapAction F.toFunctor G).map (MonoidalCategory.tensorHom f g)).hom

Next tactic:
dsimp
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; dsimp; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y X' Y' : Action V G
f : X ⟶ Y
g : X' ⟶ Y'
⊢ MonoidalCategory.tensorHom (F.map f.hom) (F.map g.hom) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y.V Y'.V =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V X'.V ≫ F.map (MonoidalCategory.tensorHom f.hom g.hom)

Next tactic:
simp
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; dsimp; simp
  associativity X Y Z := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y Z : Action V G
⊢ MonoidalCategory.tensorHom ((fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X Y)
        (𝟙 ((Functor.mapAction F.toFunctor G).obj Z)) ≫
      (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) (MonoidalCategory.tensorObj X Y) Z ≫
        (Functor.mapAction F.toFunctor G).map (MonoidalCategory.associator X Y Z).hom =
    (MonoidalCategory.associator ((Functor.mapAction F.toFunctor G).obj X) ((Functor.mapAction F.toFunctor G).obj Y)
          ((Functor.mapAction F.toFunctor G).obj Z)).hom ≫
      MonoidalCategory.tensorHom (𝟙 ((Functor.mapAction F.toFunctor G).obj X))
          ((fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) Y Z) ≫
        (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X (MonoidalCategory.tensorObj Y Z)

Next tactic:
ext
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; dsimp; simp
  associativity X Y Z := by ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y Z : Action V G
⊢ (MonoidalCategory.tensorHom ((fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X Y)
          (𝟙 ((Functor.mapAction F.toFunctor G).obj Z)) ≫
        (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) (MonoidalCategory.tensorObj X Y) Z ≫
          (Functor.mapAction F.toFunctor G).map (MonoidalCategory.associator X Y Z).hom).hom =
    ((MonoidalCategory.associator ((Functor.mapAction F.toFunctor G).obj X) ((Functor.mapAction F.toFunctor G).obj Y)
            ((Functor.mapAction F.toFunctor G).obj Z)).hom ≫
        MonoidalCategory.tensorHom (𝟙 ((Functor.mapAction F.toFunctor G).obj X))
            ((fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) Y Z) ≫
          (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) X
            (MonoidalCategory.tensorObj Y Z)).hom

Next tactic:
dsimp
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; dsimp; simp
  associativity X Y Z := by ext; dsimp; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y Z : Action V G
⊢ MonoidalCategory.tensorHom (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V) (𝟙 (F.obj Z.V)) ≫
      LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (MonoidalCategory.tensorObj X.V Y.V) Z.V ≫
        F.map
          (MonoidalCategory.tensorHom (𝟙 (MonoidalCategory.tensorObj X.V Y.V)) (𝟙 Z.V) ≫
            (MonoidalCategory.associator X.V Y.V Z.V).hom ≫
              MonoidalCategory.tensorHom (𝟙 X.V) (𝟙 (MonoidalCategory.tensorObj Y.V Z.V))) =
    (MonoidalCategory.tensorHom (𝟙 (MonoidalCategory.tensorObj (F.obj X.V) (F.obj Y.V))) (𝟙 (F.obj Z.V)) ≫
        (MonoidalCategory.associator (F.obj X.V) (F.obj Y.V) (F.obj Z.V)).hom ≫
          MonoidalCategory.tensorHom (𝟙 (F.obj X.V)) (𝟙 (MonoidalCategory.tensorObj (F.obj Y.V) (F.obj Z.V)))) ≫
      MonoidalCategory.tensorHom (𝟙 (F.obj X.V)) (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y.V Z.V) ≫
        LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V (MonoidalCategory.tensorObj Y.V Z.V)

Next tactic:
simp
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction : MonoidalFunctor (Action V G) (Action W G) where
  toFunctor := F.toFunctor.mapAction G
  ε :=
    { hom := F.ε
      comm := fun g => by
        dsimp [FunctorCategoryEquivalence.inverse, Functor.mapAction]
        rw [Category.id_comp, F.map_id, Category.comp_id] }
  μ := fun X Y =>
    { hom := F.μ X.V Y.V
      comm := fun g => F.toLaxMonoidalFunctor.μ_natural (X.ρ g) (Y.ρ g) }
  -- using `dsimp` before `simp` speeds these up
  μ_natural {X Y X' Y'} f g := by ext; dsimp; simp
  associativity X Y Z := by ext; dsimp; simp
  left_unitality X := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X : Action V G
⊢ (MonoidalCategory.leftUnitor ((Functor.mapAction F.toFunctor G).obj X)).hom =
    MonoidalCategory.tensorHom (Hom.mk F.ε) (𝟙 ((Functor.mapAction F.toFunctor G).obj X)) ≫
      (fun X Y => Hom.mk (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X.V Y.V)) (𝟙_ (Action V G)) X ≫
        (Functor.mapAction F.toFunctor G).map (MonoidalCategory.leftUnitor X).hom

Next tactic:
ext