File: Mathlib/RepresentationTheory/Action/Monoidal.lean

full_name: Action.instMonoidalCategory
code: instance instMonoidalCategory : MonoidalCategory (Action V G) 
goal: CategoryTheory.MonoidalCategory (Action V G)

full_name: Action.tensorUnit_v
code: @[simp]
theorem tensorUnit_v : (𝟙_ (Action V G)).V = 𝟙_ V 
goal: (𝟙_ (Action V G)).V = 𝟙_ V

full_name: Action.tensorUnit_rho
code: theorem tensorUnit_rho {g : G} : (𝟙_ (Action V G)).ρ g = 𝟙 (𝟙_ V) 
goal: (𝟙_ (Action V G)).ρ g = 𝟙 (𝟙_ V)

full_name: Action.tensor_v
code: @[simp]
theorem tensor_v {X Y : Action V G} : (X ⊗ Y).V = X.V ⊗ Y.V 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).V = CategoryTheory.MonoidalCategory.tensorObj X.V Y.V

full_name: Action.tensor_rho
code: theorem tensor_rho {X Y : Action V G} {g : G} : (X ⊗ Y).ρ g = X.ρ g ⊗ Y.ρ g 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).ρ g = CategoryTheory.MonoidalCategory.tensorHom (X.ρ g) (Y.ρ g)

full_name: Action.tensor_hom
code: @[simp]
theorem tensor_hom {W X Y Z : Action V G} (f : W ⟶ X) (g : Y ⟶ Z) : (f ⊗ g).hom = f.hom ⊗ g.hom 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g).hom = CategoryTheory.MonoidalCategory.tensorHom f.hom g.hom

full_name: Action.whiskerLeft_hom
code: @[simp]
theorem whiskerLeft_hom (X : Action V G) {Y Z : Action V G} (f : Y ⟶ Z) :
    (X ◁ f).hom = X.V ◁ f.hom 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).hom = CategoryTheory.MonoidalCategory.whiskerLeft X.V f.hom

full_name: Action.whiskerRight_hom
code: @[simp]
theorem whiskerRight_hom {X Y : Action V G} (f : X ⟶ Y) (Z : Action V G) :
    (f ▷ Z).hom = f.hom ▷ Z.V 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).hom = CategoryTheory.MonoidalCategory.whiskerRight f.hom Z.V

full_name: Action.associator_hom_hom
code: theorem associator_hom_hom {X Y Z : Action V G} :
    Hom.hom (α_ X Y Z).hom = (α_ X.V Y.V Z.V).hom 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.hom =
  (CategoryTheory.MonoidalCategory.associator X.V Y.V Z.V).hom

full_name: Action.associator_inv_hom
code: theorem associator_inv_hom {X Y Z : Action V G} :
    Hom.hom (α_ X Y Z).inv = (α_ X.V Y.V Z.V).inv 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.hom =
  (CategoryTheory.MonoidalCategory.associator X.V Y.V Z.V).inv

full_name: Action.leftUnitor_hom_hom
code: theorem leftUnitor_hom_hom {X : Action V G} : Hom.hom (λ_ X).hom = (λ_ X.V).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.hom = (CategoryTheory.MonoidalCategory.leftUnitor X.V).hom

full_name: Action.leftUnitor_inv_hom
code: theorem leftUnitor_inv_hom {X : Action V G} : Hom.hom (λ_ X).inv = (λ_ X.V).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.hom = (CategoryTheory.MonoidalCategory.leftUnitor X.V).inv

full_name: Action.rightUnitor_hom_hom
code: theorem rightUnitor_hom_hom {X : Action V G} : Hom.hom (ρ_ X).hom = (ρ_ X.V).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.hom = (CategoryTheory.MonoidalCategory.rightUnitor X.V).hom

full_name: Action.rightUnitor_inv_hom
code: theorem rightUnitor_inv_hom {X : Action V G} : Hom.hom (ρ_ X).inv = (ρ_ X.V).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.hom = (CategoryTheory.MonoidalCategory.rightUnitor X.V).inv

full_name: Action.tensorUnitIso
code: /-- Given an object `X` isomorphic to the tensor unit of `V`, `X` equipped with the trivial action
is isomorphic to the tensor unit of `Action V G`. -/
def tensorUnitIso {X : V} (f : 𝟙_ V ≅ X) : 𝟙_ (Action V G) ≅ Action.mk X 1 
goal: 𝟙_ (Action V G) ≅ { V := X, ρ := 1 }

full_name: Action.forgetMonoidal
code: /-- When `V` is monoidal the forgetful functor `Action V G` to `V` is monoidal. -/
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
goal: CategoryTheory.MonoidalFunctor (Action V G) V

full_name: Action.forgetMonoidal_toLaxMonoidalFunctor_ε
code: /-- When `V` is monoidal the forgetful functor `Action V G` to `V` is monoidal. -/
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
goal: (Action.forgetMonoidal V G).ε = 𝟙 (𝟙_ V)

full_name: Action.forgetMonoidal_toLaxMonoidalFunctor_toFunctor
code: /-- When `V` is monoidal the forgetful functor `Action V G` to `V` is monoidal. -/
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
goal: (Action.forgetMonoidal V G).toFunctor = Action.forget V G

full_name: Action.forgetMonoidal_toLaxMonoidalFunctor_μ
code: /-- When `V` is monoidal the forgetful functor `Action V G` to `V` is monoidal. -/
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
goal: (Action.forgetMonoidal V G).μ X Y =
  𝟙 (CategoryTheory.MonoidalCategory.tensorObj ((Action.forget V G).obj X) ((Action.forget V G).obj Y))

full_name: Action.forgetMonoidal_faithful
code: instance forgetMonoidal_faithful : (forgetMonoidal V G).Faithful 
goal: (Action.forgetMonoidal V G).Faithful

full_name: Action.instBraidedCategory
code: instance : BraidedCategory (Action V G) 
goal: CategoryTheory.BraidedCategory (Action V G)

full_name: Action.forgetBraided_ε
code: /-- When `V` is braided the forgetful functor `Action V G` to `V` is braided. -/
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
goal: (Action.forgetBraided V G).ε = 𝟙 (𝟙_ V)

full_name: Action.forgetBraided_map
code: /-- When `V` is braided the forgetful functor `Action V G` to `V` is braided. -/
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
goal: ∀ {X Y : Action V G} (f : X ⟶ Y), (Action.forgetBraided V G).map f = f.hom

full_name: Action.forgetBraided_μ
code: /-- When `V` is braided the forgetful functor `Action V G` to `V` is braided. -/
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
goal: (Action.forgetBraided V G).μ X Y = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.V Y.V)

full_name: Action.forgetBraided_obj
code: /-- When `V` is braided the forgetful functor `Action V G` to `V` is braided. -/
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
goal: (Action.forgetBraided V G).obj M = M.V

full_name: Action.forgetBraided
code: /-- When `V` is braided the forgetful functor `Action V G` to `V` is braided. -/
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
goal: CategoryTheory.BraidedFunctor (Action V G) V

full_name: Action.forgetBraided_faithful
code: instance forgetBraided_faithful : (forgetBraided V G).Faithful 
goal: (Action.forgetBraided V G).Faithful

full_name: Action.instSymmetricCategory
code: instance [SymmetricCategory V] : SymmetricCategory (Action V G) 
goal: CategoryTheory.SymmetricCategory (Action V G)

full_name: Action.instMonoidalPreadditive
code: instance : MonoidalPreadditive (Action V G) 
goal: CategoryTheory.MonoidalPreadditive (Action V G)

full_name: Action.instMonoidalLinear
code: instance : MonoidalLinear R (Action V G) 
goal: CategoryTheory.MonoidalLinear R (Action V G)

full_name: Action.functorCategoryMonoidalEquivalence
code: /-- Upgrading the functor `Action V G ⥤ (SingleObj G ⥤ V)` to a monoidal functor. -/
def functorCategoryMonoidalEquivalence : MonoidalFunctor (Action V G) (SingleObj G ⥤ V) 
goal: CategoryTheory.MonoidalFunctor (Action V G) (CategoryTheory.SingleObj ↑G ⥤ V)

full_name: Action.functorCategoryMonoidalEquivalenceInverse
code: /-- Upgrading the functor `(SingleObj G ⥤ V) ⥤ Action V G` to a monoidal functor. -/
def functorCategoryMonoidalEquivalenceInverse : MonoidalFunctor (SingleObj G ⥤ V) (Action V G) 
goal: CategoryTheory.MonoidalFunctor (CategoryTheory.SingleObj ↑G ⥤ V) (Action V G)

full_name: Action.functorCategoryMonoidalAdjunction
code: /-- The adjunction (which is an equivalence) between the categories
`Action V G` and `(SingleObj G ⥤ V)`. -/
def functorCategoryMonoidalAdjunction :
    (functorCategoryMonoidalEquivalence V G).toFunctor ⊣
      (functorCategoryMonoidalEquivalenceInverse V G).toFunctor 
goal: (Action.functorCategoryMonoidalEquivalence V G).toFunctor ⊣
  (Action.functorCategoryMonoidalEquivalenceInverse V G).toFunctor

full_name: Action.instIsEquivalenceFunctorSingleObjαMonoidFunctorCategoryMonoidalEquivalence
code: instance : (functorCategoryMonoidalEquivalence V G).IsEquivalence 
goal: (Action.functorCategoryMonoidalEquivalence V G).IsEquivalence

full_name: Action.functorCategoryMonoidalEquivalence.μ_app
code: @[simp]
theorem functorCategoryMonoidalEquivalence.μ_app (A B : Action V G) :
    ((functorCategoryMonoidalEquivalence V G).μ A B).app PUnit.unit = 𝟙 _ 
goal: ((Action.functorCategoryMonoidalEquivalence V G).μ A B).app PUnit.unit =
  𝟙
    ((CategoryTheory.MonoidalCategory.tensorObj ((Action.functorCategoryMonoidalEquivalence V G).obj A)
          ((Action.functorCategoryMonoidalEquivalence V G).obj B)).obj
      PUnit.unit)

full_name: Action.functorCategoryMonoidalEquivalence.μIso_inv_app
code: @[simp]
theorem functorCategoryMonoidalEquivalence.μIso_inv_app (A B : Action V G) :
    ((functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit = 𝟙 _ 
goal: ((Action.functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit =
  𝟙
    (((Action.functorCategoryMonoidalEquivalence V G).obj (CategoryTheory.MonoidalCategory.tensorObj A B)).obj
      PUnit.unit)

full_name: Action.functorCategoryMonoidalEquivalence.ε_app
code: @[simp]
theorem functorCategoryMonoidalEquivalence.ε_app :
    (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 _ 
goal: (Action.functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit =
  𝟙 ((𝟙_ (CategoryTheory.SingleObj ↑G ⥤ V)).obj PUnit.unit)

full_name: Action.functorCategoryMonoidalAdjunction.unit_app_hom
code: @[simp]
theorem functorCategoryMonoidalAdjunction.unit_app_hom (A : Action V G) :
    ((functorCategoryMonoidalAdjunction _ _).unit.app A).hom = 𝟙 _ 
goal: ((Action.functorCategoryMonoidalAdjunction V G).unit.app A).hom = 𝟙 ((𝟭 (Action V G)).obj A).V

full_name: Action.functorCategoryMonoidalAdjunction.counit_app_app
code: @[simp]
theorem functorCategoryMonoidalAdjunction.counit_app_app (A : SingleObj G ⥤ V) :
    ((functorCategoryMonoidalAdjunction _ _).counit.app A).app PUnit.unit = 𝟙 _ 
goal: ((Action.functorCategoryMonoidalAdjunction V G).counit.app A).app PUnit.unit =
  𝟙
    ((((Action.functorCategoryMonoidalEquivalenceInverse V G).toFunctor ⋙
              (Action.functorCategoryMonoidalEquivalence V G).toFunctor).obj
          A).obj
      PUnit.unit)

full_name: Action.functorCategoryMonoidalEquivalence.functor_map
code: @[simp]
theorem functorCategoryMonoidalEquivalence.functor_map {A B : Action V G} (f : A ⟶ B) :
    (functorCategoryMonoidalEquivalence _ _).map f = FunctorCategoryEquivalence.functor.map f 
goal: (Action.functorCategoryMonoidalEquivalence V G).map f = Action.FunctorCategoryEquivalence.functor.map f

full_name: Action.functorCategoryMonoidalEquivalence.inverse_map
code: @[simp]
theorem functorCategoryMonoidalEquivalence.inverse_map {A B : SingleObj G ⥤ V} (f : A ⟶ B) :
    (functorCategoryMonoidalEquivalenceInverse _ _).map f =
      FunctorCategoryEquivalence.inverse.map f 
goal: (Action.functorCategoryMonoidalEquivalenceInverse V G).map f = Action.FunctorCategoryEquivalence.inverse.map f

full_name: Action.instRightRigidCategoryFunctorSingleObjαMonoidObjGrpMonCatForget₂
code: instance [RightRigidCategory V] : RightRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) 
goal: CategoryTheory.RightRigidCategory (CategoryTheory.SingleObj ↑((CategoryTheory.forget₂ Grp MonCat).obj H) ⥤ V)

full_name: Action.instRightRigidCategoryObjGrpMonCatForget₂
code: /-- If `V` is right rigid, so is `Action V G`. -/
instance [RightRigidCategory V] : RightRigidCategory (Action V H) 
goal: CategoryTheory.RightRigidCategory (Action V ((CategoryTheory.forget₂ Grp MonCat).obj H))

full_name: Action.instLeftRigidCategoryFunctorSingleObjαMonoidObjGrpMonCatForget₂
code: instance [LeftRigidCategory V] : LeftRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) 
goal: CategoryTheory.LeftRigidCategory (CategoryTheory.SingleObj ↑((CategoryTheory.forget₂ Grp MonCat).obj H) ⥤ V)

full_name: Action.instLeftRigidCategoryObjGrpMonCatForget₂
code: /-- If `V` is left rigid, so is `Action V G`. -/
instance [LeftRigidCategory V] : LeftRigidCategory (Action V H) 
goal: CategoryTheory.LeftRigidCategory (Action V ((CategoryTheory.forget₂ Grp MonCat).obj H))

full_name: Action.instRigidCategoryFunctorSingleObjαMonoidObjGrpMonCatForget₂
code: instance [RigidCategory V] : RigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) 
goal: CategoryTheory.RigidCategory (CategoryTheory.SingleObj ↑((CategoryTheory.forget₂ Grp MonCat).obj H) ⥤ V)

full_name: Action.instRigidCategoryObjGrpMonCatForget₂
code: /-- If `V` is rigid, so is `Action V G`. -/
instance [RigidCategory V] : RigidCategory (Action V H) 
goal: CategoryTheory.RigidCategory (Action V ((CategoryTheory.forget₂ Grp MonCat).obj H))

full_name: Action.rightDual_v
code: @[simp]
theorem rightDual_v [RightRigidCategory V] : Xᘁ.V = X.Vᘁ 
goal: Xᘁ.V = X.Vᘁ

full_name: Action.leftDual_v
code: @[simp]
theorem leftDual_v [LeftRigidCategory V] : (ᘁX).V = ᘁX.V 
goal: (ᘁX).V = ᘁX.V

full_name: Action.rightDual_ρ
code: @[simp, nolint simpNF]
theorem rightDual_ρ [RightRigidCategory V] (h : H) : Xᘁ.ρ h = (X.ρ (h⁻¹ : H))ᘁ 
goal: Xᘁ.ρ h = X.ρ h⁻¹ᘁ

full_name: Action.leftDual_ρ
code: @[simp, nolint simpNF]
theorem leftDual_ρ [LeftRigidCategory V] (h : H) : (ᘁX).ρ h = ᘁX.ρ (h⁻¹ : H) 
goal: (ᘁX).ρ h = ᘁX.ρ h⁻¹

full_name: Action.leftRegularTensorIso
code: /-- 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 
goal: CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) X ≅
  CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) { V := X.V, ρ := 1 }

full_name: Action.leftRegularTensorIso_hom_hom
code: /-- 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 
goal: (Action.leftRegularTensorIso G X).hom.hom g = (g.1, X.ρ g.1⁻¹ g.2)

full_name: Action.leftRegularTensorIso_inv_hom
code: /-- 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 
goal: (Action.leftRegularTensorIso G X).inv.hom g = (g.1, X.ρ g.1 g.2)

full_name: Action.diagonalSucc
code: /-- The natural isomorphism of `G`-sets `Gⁿ⁺¹ ≅ G × Gⁿ`, where `G` acts by left multiplication on
each factor. -/
@[simps!]
noncomputable def diagonalSucc (G : Type u) [Monoid G] (n : ℕ) :
    diagonal G (n + 1) ≅ leftRegular G ⊗ diagonal G n 
goal: Action.diagonal G (n + 1) ≅ CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) (Action.diagonal G n)

full_name: Action.diagonalSucc_inv_hom
code: /-- The natural isomorphism of `G`-sets `Gⁿ⁺¹ ≅ G × Gⁿ`, where `G` acts by left multiplication on
each factor. -/
@[simps!]
noncomputable def diagonalSucc (G : Type u) [Monoid G] (n : ℕ) :
    diagonal G (n + 1) ≅ leftRegular G ⊗ diagonal G n 
goal: ∀ (a : (CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) (Action.diagonal G n)).V),
  (Action.diagonalSucc G n).inv.hom a = (Equiv.piFinSuccAbove (fun a => G) 0).symm a

full_name: Action.diagonalSucc_hom_hom
code: /-- The natural isomorphism of `G`-sets `Gⁿ⁺¹ ≅ G × Gⁿ`, where `G` acts by left multiplication on
each factor. -/
@[simps!]
noncomputable def diagonalSucc (G : Type u) [Monoid G] (n : ℕ) :
    diagonal G (n + 1) ≅ leftRegular G ⊗ diagonal G n 
goal: ∀ (a : (Action.diagonal G (n + 1)).V), (Action.diagonalSucc G n).hom.hom a = (Equiv.piFinSuccAbove (fun a => G) 0) a

full_name: CategoryTheory.MonoidalFunctor.mapActionLax_ε_hom
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: (CategoryTheory.MonoidalFunctor.mapActionLax F G).ε.hom = F.ε

full_name: CategoryTheory.MonoidalFunctor.mapActionLax_toFunctor_obj_V
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: ∀ (a : Action V G), ((CategoryTheory.MonoidalFunctor.mapActionLax F G).obj a).V = F.obj a.V

full_name: CategoryTheory.MonoidalFunctor.mapActionLax_toFunctor_obj_ρ_apply
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: ∀ (a : Action V G) (g : ↑G), ((CategoryTheory.MonoidalFunctor.mapActionLax F G).obj a).ρ g = F.map (a.ρ g)

full_name: CategoryTheory.MonoidalFunctor.mapActionLax_μ_hom
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: ((CategoryTheory.MonoidalFunctor.mapActionLax F G).μ X Y).hom = F.μ X.V Y.V

full_name: CategoryTheory.MonoidalFunctor.mapActionLax_toFunctor_map_hom
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: ∀ {X Y : Action V G} (a : X ⟶ Y), ((CategoryTheory.MonoidalFunctor.mapActionLax F G).map a).hom = F.map a.hom

full_name: CategoryTheory.MonoidalFunctor.mapActionLax
code: /-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G) 
goal: CategoryTheory.LaxMonoidalFunctor (Action V G) (Action W G)

full_name: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_toFunctor_obj_ρ_apply
code: /-- 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) 
goal: ∀ (a : Action V G) (g : ↑G), ((F.mapAction G).obj a).ρ g = F.map (a.ρ g)

full_name: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_μ_hom
code: /-- 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) 
goal: ((F.mapAction G).μ X Y).hom = F.μ X.V Y.V

full_name: CategoryTheory.MonoidalFunctor.mapAction
code: /-- 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) 
goal: CategoryTheory.MonoidalFunctor (Action V G) (Action W G)

full_name: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_ε_hom
code: /-- 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) 
goal: (F.mapAction G).ε.hom = F.ε

full_name: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_toFunctor_map_hom
code: /-- 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) 
goal: ∀ {X Y : Action V G} (a : X ⟶ Y), ((F.mapAction G).map a).hom = F.map a.hom

full_name: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_toFunctor_obj_V
code: /-- 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) 
goal: ∀ (a : Action V G), ((F.mapAction G).obj a).V = F.obj a.V

full_name: CategoryTheory.MonoidalFunctor.mapAction_ε_inv_hom
code: @[simp]
theorem mapAction_ε_inv_hom : (inv (F.mapAction G).ε).hom = inv F.ε 
goal: (CategoryTheory.inv (F.mapAction G).ε).hom = CategoryTheory.inv F.ε

full_name: CategoryTheory.MonoidalFunctor.mapAction_μ_inv_hom
code: @[simp]
theorem mapAction_μ_inv_hom (X Y : Action V G) :
    (inv ((F.mapAction G).μ X Y)).hom = inv (F.μ X.V Y.V) 
goal: (CategoryTheory.inv ((F.mapAction G).μ X Y)).hom = CategoryTheory.inv (F.μ X.V Y.V)