l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem functorCategoryMonoidalEquivalence.μIso_inv_app (A B : Action V G) :
    ((functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit = 𝟙 _ := by
  rw [← NatIso.app_inv, ← IsIso.Iso.inv_hom]
  refine' IsIso.inv_eq_of_hom_inv_id _
  

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((MonoidalFunctor.μIso (functorCategoryMonoidalEquivalence V G) A B).app PUnit.unit).hom ≫
      𝟙 (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj (A ⊗ B)).obj PUnit.unit) =
    𝟙
      (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj A ⊗
            (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj B).obj
        PUnit.unit)

Next tactic:
rw [Category.comp_id, NatIso.app_hom, MonoidalFunctor.μIso_hom,
    functorCategoryMonoidalEquivalence.μ_app]
@[simp]
theorem functorCategoryMonoidalEquivalence.ε_app :
    (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 _ := by
  

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.ε.app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)

Next tactic:
dsimp only [functorCategoryMonoidalEquivalence]
@[simp]
theorem functorCategoryMonoidalEquivalence.ε_app :
    (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 _ := by
  dsimp only [functorCategoryMonoidalEquivalence]
  

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (Monoidal.fromTransported (functorCategoryEquivalence V G).symm).toLaxMonoidalFunctor.ε.app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)

Next tactic:
simp only [Monoidal.fromTransported_toLaxMonoidalFunctor_ε]
@[simp]
theorem functorCategoryMonoidalEquivalence.ε_app :
    (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 _ := by
  dsimp only [functorCategoryMonoidalEquivalence]
  simp only [Monoidal.fromTransported_toLaxMonoidalFunctor_ε]
  

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ ((functorCategoryEquivalence V G).symm.unitIso.hom.app (𝟙_ (SingleObj ↑G ⥤ V))).app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)

Next tactic:
rfl
instance [RightRigidCategory V] : RightRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : RightRigidCategory V
⊢ RightRigidCategory (SingleObj ↑((forget₂ GroupCat MonCat).obj H) ⥤ V)

Next tactic:
change RightRigidCategory (SingleObj H ⥤ V)
instance [RightRigidCategory V] : RightRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  change RightRigidCategory (SingleObj H ⥤ V); 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : RightRigidCategory V
⊢ RightRigidCategory (SingleObj ↑H ⥤ V)

Next tactic:
infer_instance
instance [LeftRigidCategory V] : LeftRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : LeftRigidCategory V
⊢ LeftRigidCategory (SingleObj ↑((forget₂ GroupCat MonCat).obj H) ⥤ V)

Next tactic:
change LeftRigidCategory (SingleObj H ⥤ V)
instance [LeftRigidCategory V] : LeftRigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  change LeftRigidCategory (SingleObj H ⥤ V); 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : LeftRigidCategory V
⊢ LeftRigidCategory (SingleObj ↑H ⥤ V)

Next tactic:
infer_instance
instance [RigidCategory V] : RigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : RigidCategory V
⊢ RigidCategory (SingleObj ↑((forget₂ GroupCat MonCat).obj H) ⥤ V)

Next tactic:
change RigidCategory (SingleObj H ⥤ V)
instance [RigidCategory V] : RigidCategory (SingleObj (H : MonCat.{u}) ⥤ V) := by
  change RigidCategory (SingleObj H ⥤ V); 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
inst✝ : RigidCategory V
⊢ RigidCategory (SingleObj ↑H ⥤ V)

Next tactic:
infer_instance
@[simp, nolint simpNF]
theorem rightDual_ρ [RightRigidCategory V] (h : H) : Xᘁ.ρ h = (X.ρ (h⁻¹ : H))ᘁ := by
  

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ Xᘁ.ρ h = X.ρ h⁻¹ᘁ

Next tactic:
rw [← SingleObj.inv_as_inv]
@[simp, nolint simpNF]
theorem rightDual_ρ [RightRigidCategory V] (h : H) : Xᘁ.ρ h = (X.ρ (h⁻¹ : H))ᘁ := by
  rw [← SingleObj.inv_as_inv]; 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ Xᘁ.ρ h = X.ρ (inv h)ᘁ
case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1
case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1

Next tactic:
rfl
@[simp, nolint simpNF]
theorem leftDual_ρ [LeftRigidCategory V] (h : H) : (ᘁX).ρ h = ᘁX.ρ (h⁻¹ : H) := by
  

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ (ᘁX).ρ h = ᘁX.ρ h⁻¹

Next tactic:
rw [← SingleObj.inv_as_inv]
@[simp, nolint simpNF]
theorem leftDual_ρ [LeftRigidCategory V] (h : H) : (ᘁX).ρ h = ᘁX.ρ (h⁻¹ : H) := by
  rw [← SingleObj.inv_as_inv]; 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ (ᘁX).ρ h = ᘁX.ρ (inv h)
case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1
case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1

Next tactic:
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
        

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

Next tactic:
funext ⟨(x₁ : G), (x₂ : X.V)⟩
/-- 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)⟩
        

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
g x₁ : G
x₂ : X.V
⊢ ((leftRegular G ⊗ X).ρ g ≫ fun g => (g.1, X.ρ g.1⁻¹ g.2)) (x₁, x₂) =
    ((fun g => (g.1, X.ρ g.1⁻¹ g.2)) ≫ (leftRegular G ⊗ { V := X.V, ρ := 1 }).ρ g) (x₁, 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 _
        

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

Next tactic:
change (X.ρ ((g * x₁)⁻¹ : G) * X.ρ g) x₂ = 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.ρ _ _
        

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

Next tactic:
rw [mul_inv_rev, ← X.ρ.map_mul, inv_mul_cancel_right]
/-- 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
        

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

Next tactic:
funext ⟨(x₁ : G), (x₂ : X.V)⟩
/-- 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)⟩
        

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
g x₁ : G
x₂ : X.V
⊢ ((leftRegular G ⊗ { V := X.V, ρ := 1 }).ρ g ≫ fun g => (g.1, X.ρ g.1 g.2)) (x₁, x₂) =
    ((fun g => (g.1, X.ρ g.1 g.2)) ≫ (leftRegular G ⊗ X).ρ g) (x₁, 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 _
        

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

Next tactic:
erw [tensor_rho, tensor_rho]
/-- 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]
        

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

Next tactic:
dsimp
/-- 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
        

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
g x₁ : G
x₂ : X.V
⊢ X.ρ ((leftRegular G).ρ g x₁) x₂ = X.ρ g (X.ρ x₁ x₂)

Next tactic:
erw [leftRegular_ρ_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]
        

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
g x₁ : G
x₂ : X.V
⊢ X.ρ (g • x₁) x₂ = X.ρ g (X.ρ x₁ x₂)

Next tactic:
erw [map_mul]
/-- 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]
        

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G✝ : MonCat
G : Type u
inst✝ : Group G
X : Action (Type u) (MonCat.of G)
g x₁ : G
x₂ : X.V
⊢ (X.ρ g * X.ρ x₁) x₂ = X.ρ g (X.ρ x₁ x₂)

Next tactic:
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
    

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 ⊗ X)

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
    

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 ⊗ X)).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
    

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 =
    Hom.hom (𝟙 (leftRegular G ⊗ X)) x

Next tactic:
refine' Prod.ext rfl _