Theorem: Action.functorCategoryMonoidalEquivalence.μ_app
File: Mathlib/RepresentationTheory/Action.lean

tactic: dsimp only [functorCategoryMonoidalEquivalence]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (LaxMonoidalFunctor.μ (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor A B).app PUnit.unit =
    𝟙
      (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj A ⊗
            (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj B).obj
        PUnit.unit)

tactic: simp only [Monoidal.fromTransported_toLaxMonoidalFunctor_μ, NatTrans.comp_app]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (LaxMonoidalFunctor.μ
          (Monoidal.fromTransported
              (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).toLaxMonoidalFunctor
          A B).app
      PUnit.unit =
    𝟙
      (((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              A ⊗
            (Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              B).obj
        PUnit.unit)

tactic: dsimp [Equivalence.unit]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((Equivalence.unit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
            ((Functor.asEquivalence
                      (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.obj
                A ⊗
              (Functor.asEquivalence
                      (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.obj
                B)).app
        PUnit.unit ≫
      (inv
              ((Functor.asEquivalence
                      (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.map
                ((CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor.map
                  ((Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      ((Functor.asEquivalence
                              (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.obj
                        A) ⊗
                    (Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      ((Functor.asEquivalence
                              (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.obj
                        B))))).app
          PUnit.unit ≫
        ((Functor.asEquivalence (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor).inverse.map
              ((CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).functor.map
                ((CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).inverse.map
                    ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app A) ⊗
                  (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G)).inverse.map
                    ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      B)))).app
          PUnit.unit =
    𝟙
      (((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              A ⊗
            (Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              B).obj
        PUnit.unit)

tactic: erw [Category.id_comp]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ 𝟙
        (((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A).obj PUnit.unit ⊗
          ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B).obj PUnit.unit) ≫
      (inv
              ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
                (FunctorCategoryEquivalence.inverse.map
                  ((Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A) ⊗
                    (Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B))))).app
          PUnit.unit ≫
        ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
              (FunctorCategoryEquivalence.inverse.map
                (FunctorCategoryEquivalence.functor.map
                    ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app A) ⊗
                  FunctorCategoryEquivalence.functor.map
                    ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                      B)))).app
          PUnit.unit =
    𝟙
      (((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              A).obj
          PUnit.unit ⊗
        ((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              B).obj
          PUnit.unit)

tactic: rw [NatIso.isIso_inv_app, IsIso.inv_comp_eq]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (inv
            ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
              (FunctorCategoryEquivalence.inverse.map
                ((Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A) ⊗
                  (Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B))))).app
        PUnit.unit ≫
      ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
            (FunctorCategoryEquivalence.inverse.map
              (FunctorCategoryEquivalence.functor.map
                  ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app A) ⊗
                FunctorCategoryEquivalence.functor.map
                  ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app B)))).app
        PUnit.unit =
    𝟙
      (((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              A).obj
          PUnit.unit ⊗
        ((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              B).obj
          PUnit.unit)

tactic: erw [MonoidalCategory.tensor_id]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
          (FunctorCategoryEquivalence.inverse.map
            (FunctorCategoryEquivalence.functor.map
                ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app A) ⊗
              FunctorCategoryEquivalence.functor.map
                ((Equivalence.counit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app B)))).app
      PUnit.unit =
    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
            (FunctorCategoryEquivalence.inverse.map
              ((Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                  ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A) ⊗
                (Equivalence.unitInv (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
                  ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B)))).app
        PUnit.unit ≫
      𝟙
        (((Monoidal.fromTransported
                        (CategoryTheory.Equivalence.symm
                          (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
                A).obj
            PUnit.unit ⊗
          ((Monoidal.fromTransported
                        (CategoryTheory.Equivalence.symm
                          (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
                B).obj
            PUnit.unit)

tactic: erw [(functorCategoryEquivalence V G).inverse.map_id,
  (functorCategoryEquivalence V G).functor.map_id, Category.id_comp]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
          (FunctorCategoryEquivalence.inverse.map
            (𝟙
              (FunctorCategoryEquivalence.functor.obj
                  (FunctorCategoryEquivalence.inverse.obj
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A)) ⊗
                FunctorCategoryEquivalence.functor.obj
                  (FunctorCategoryEquivalence.inverse.obj
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B)))))).app
      PUnit.unit =
    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.map
            (FunctorCategoryEquivalence.inverse.map
              (𝟙
                (FunctorCategoryEquivalence.functor.obj
                    (FunctorCategoryEquivalence.inverse.obj
                      ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A)) ⊗
                  FunctorCategoryEquivalence.functor.obj
                    (FunctorCategoryEquivalence.inverse.obj
                      ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B)))))).app
        PUnit.unit ≫
      𝟙
        (((Monoidal.fromTransported
                        (CategoryTheory.Equivalence.symm
                          (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
                A).obj
            PUnit.unit ⊗
          ((Monoidal.fromTransported
                        (CategoryTheory.Equivalence.symm
                          (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
                B).obj
            PUnit.unit)

tactic: rfl
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (𝟙
          ((functorCategoryEquivalence V G).functor.obj
            (FunctorCategoryEquivalence.inverse.obj
              (FunctorCategoryEquivalence.functor.obj
                  (FunctorCategoryEquivalence.inverse.obj
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj A)) ⊗
                FunctorCategoryEquivalence.functor.obj
                  (FunctorCategoryEquivalence.inverse.obj
                    ((Functor.asEquivalence FunctorCategoryEquivalence.inverse).inverse.obj B)))))).app
      PUnit.unit =
    𝟙
      (((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              A).obj
          PUnit.unit ⊗
        ((Monoidal.fromTransported
                      (CategoryTheory.Equivalence.symm
                        (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.toFunctor.obj
              B).obj
          PUnit.unit)