File: Mathlib/RepresentationTheory/Action/Basic.lean

full_name: Action
code: /-- An `Action V G` represents a bundled action of
the monoid `G` on an object of some category `V`.

As an example, when `V = ModuleCat R`, this is an `R`-linear representation of `G`,
while when `V = Type` this is a `G`-action.
-/
structure Action (G : MonCat.{u}) where
  V : V
  ρ : G ⟶ MonCat.of (End V)
goal: Type (u + 1)

full_name: Action.ρ
code: /-- An `Action V G` represents a bundled action of
the monoid `G` on an object of some category `V`.

As an example, when `V = ModuleCat R`, this is an `R`-linear representation of `G`,
while when `V = Type` this is a `G`-action.
-/
structure Action (G : MonCat.{u}) where
  V : V
  ρ : G ⟶ MonCat.of (End V)
goal: G ⟶ MonCat.of (CategoryTheory.End self.V)

full_name: Action.V
code: /-- An `Action V G` represents a bundled action of
the monoid `G` on an object of some category `V`.

As an example, when `V = ModuleCat R`, this is an `R`-linear representation of `G`,
while when `V = Type` this is a `G`-action.
-/
structure Action (G : MonCat.{u}) where
  V : V
  ρ : G ⟶ MonCat.of (End V)
goal: V

full_name: Action.ρ_one
code: @[simp 1100]
theorem ρ_one {G : MonCat.{u}} (A : Action V G) : A.ρ 1 = 𝟙 A.V 
goal: A.ρ 1 = 𝟙 A.V

full_name: Action.ρAut_apply_hom
code: /-- When a group acts, we can lift the action to the group of automorphisms. -/
@[simps]
def ρAut {G : Grp.{u}} (A : Action V (MonCat.of G)) : G ⟶ Grp.of (Aut A.V) 
goal: (A.ρAut g).hom = A.ρ g

full_name: Action.ρAut_apply_inv
code: /-- When a group acts, we can lift the action to the group of automorphisms. -/
@[simps]
def ρAut {G : Grp.{u}} (A : Action V (MonCat.of G)) : G ⟶ Grp.of (Aut A.V) 
goal: (A.ρAut g).inv = A.ρ g⁻¹

full_name: Action.ρAut
code: /-- When a group acts, we can lift the action to the group of automorphisms. -/
@[simps]
def ρAut {G : Grp.{u}} (A : Action V (MonCat.of G)) : G ⟶ Grp.of (Aut A.V) 
goal: G ⟶ Grp.of (CategoryTheory.Aut A.V)

full_name: Action.inhabited'
code: instance inhabited' : Inhabited (Action (Type u) G) 
goal: Inhabited (Action (Type u) G)

full_name: Action.trivial
code: /-- The trivial representation of a group. -/
def trivial : Action AddCommGrp G 
goal: Action AddCommGrp G

full_name: Action.instInhabitedAddCommGrp
code: instance : Inhabited (Action AddCommGrp G) 
goal: Inhabited (Action AddCommGrp G)

full_name: Action.Hom
code: /-- A homomorphism of `Action V G`s is a morphism between the underlying objects,
commuting with the action of `G`.
-/
@[ext]
structure Hom (M N : Action V G) where
  hom : M.V ⟶ N.V
  comm : ∀ g : G, M.ρ g ≫ hom = hom ≫ N.ρ g := by aesop_cat
goal: Type u

full_name: Action.Hom.hom
code: /-- A homomorphism of `Action V G`s is a morphism between the underlying objects,
commuting with the action of `G`.
-/
@[ext]
structure Hom (M N : Action V G) where
  hom : M.V ⟶ N.V
  comm : ∀ g : G, M.ρ g ≫ hom = hom ≫ N.ρ g := by aesop_cat
goal: M.V ⟶ N.V

full_name: Action.Hom.comm
code: /-- A homomorphism of `Action V G`s is a morphism between the underlying objects,
commuting with the action of `G`.
-/
@[ext]
structure Hom (M N : Action V G) where
  hom : M.V ⟶ N.V
  comm : ∀ g : G, M.ρ g ≫ hom = hom ≫ N.ρ g := by aesop_cat
goal: M.ρ g ≫ self.hom = self.hom ≫ N.ρ g

full_name: Action.Hom.id_hom
code: /-- The identity morphism on an `Action V G`. -/
@[simps]
def id (M : Action V G) : Action.Hom M M 
goal: (Action.Hom.id M).hom = 𝟙 M.V

full_name: Action.Hom.id
code: /-- The identity morphism on an `Action V G`. -/
@[simps]
def id (M : Action V G) : Action.Hom M M 
goal: M.Hom M

full_name: Action.Hom.instInhabited
code: instance (M : Action V G) : Inhabited (Action.Hom M M) 
goal: Inhabited (M.Hom M)

full_name: Action.Hom.comp
code: /-- The composition of two `Action V G` homomorphisms is the composition of the underlying maps.
-/
@[simps]
def comp {M N K : Action V G} (p : Action.Hom M N) (q : Action.Hom N K) : Action.Hom M K 
goal: M.Hom K

full_name: Action.Hom.comp_hom
code: /-- The composition of two `Action V G` homomorphisms is the composition of the underlying maps.
-/
@[simps]
def comp {M N K : Action V G} (p : Action.Hom M N) (q : Action.Hom N K) : Action.Hom M K 
goal: (p.comp q).hom = p.hom ≫ q.hom

full_name: Action.instCategory
code: instance : Category (Action V G) 
goal: CategoryTheory.Category.{u, u + 1} (Action V G)

full_name: Action.hom_ext
code: @[ext]
lemma hom_ext {M N : Action V G} (φ₁ φ₂ : M ⟶ N) (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂ 
goal: φ₁ = φ₂

full_name: Action.id_hom
code: @[simp]
theorem id_hom (M : Action V G) : (𝟙 M : Hom M M).hom = 𝟙 M.V 
goal: (𝟙 M).hom = 𝟙 M.V

full_name: Action.comp_hom
code: @[simp]
theorem comp_hom {M N K : Action V G} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : Hom M K).hom = f.hom ≫ g.hom 
goal: (f ≫ g).hom = f.hom ≫ g.hom

full_name: Action.mkIso_hom_hom
code: /-- Construct an isomorphism of `G` actions/representations
from an isomorphism of the underlying objects,
where the forward direction commutes with the group action. -/
@[simps]
def mkIso {M N : Action V G} (f : M.V ≅ N.V)
    (comm : ∀ g : G, M.ρ g ≫ f.hom = f.hom ≫ N.ρ g := by aesop_cat) : M ≅ N 
goal: (Action.mkIso f comm).hom.hom = f.hom

full_name: Action.mkIso
code: /-- Construct an isomorphism of `G` actions/representations
from an isomorphism of the underlying objects,
where the forward direction commutes with the group action. -/
@[simps]
def mkIso {M N : Action V G} (f : M.V ≅ N.V)
    (comm : ∀ g : G, M.ρ g ≫ f.hom = f.hom ≫ N.ρ g := by aesop_cat) : M ≅ N 
goal: M ≅ N

full_name: Action.mkIso_inv_hom
code: /-- Construct an isomorphism of `G` actions/representations
from an isomorphism of the underlying objects,
where the forward direction commutes with the group action. -/
@[simps]
def mkIso {M N : Action V G} (f : M.V ≅ N.V)
    (comm : ∀ g : G, M.ρ g ≫ f.hom = f.hom ≫ N.ρ g := by aesop_cat) : M ≅ N 
goal: (Action.mkIso f comm).inv.hom = f.inv

full_name: Action.isIso_of_hom_isIso
code: instance (priority := 100) isIso_of_hom_isIso {M N : Action V G} (f : M ⟶ N) [IsIso f.hom] :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: Action.isIso_hom_mk
code: instance isIso_hom_mk {M N : Action V G} (f : M.V ⟶ N.V) [IsIso f] (w) :
    @IsIso _ _ M N (Hom.mk f w) 
goal: CategoryTheory.IsIso { hom := f, comm := w }

full_name: Action.FunctorCategoryEquivalence.functor_map_app
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def functor : Action V G ⥤ SingleObj G ⥤ V 
goal: ∀ {X Y : Action V G} (f : X ⟶ Y) (x : CategoryTheory.SingleObj ↑G),
  (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom

full_name: Action.FunctorCategoryEquivalence.functor_obj_map
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def functor : Action V G ⥤ SingleObj G ⥤ V 
goal: ∀ {X Y : CategoryTheory.SingleObj ↑G} (g : X ⟶ Y), (Action.FunctorCategoryEquivalence.functor.obj M).map g = M.ρ g

full_name: Action.FunctorCategoryEquivalence.functor
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def functor : Action V G ⥤ SingleObj G ⥤ V 
goal: Action V G ⥤ CategoryTheory.SingleObj ↑G ⥤ V

full_name: Action.FunctorCategoryEquivalence.functor_obj_obj
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def functor : Action V G ⥤ SingleObj G ⥤ V 
goal: ∀ (x : CategoryTheory.SingleObj ↑G), (Action.FunctorCategoryEquivalence.functor.obj M).obj x = M.V

full_name: Action.FunctorCategoryEquivalence.inverse_map_hom
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def inverse : (SingleObj G ⥤ V) ⥤ Action V G 
goal: ∀ {X Y : CategoryTheory.SingleObj ↑G ⥤ V} (f : X ⟶ Y),
  (Action.FunctorCategoryEquivalence.inverse.map f).hom = f.app PUnit.unit

full_name: Action.FunctorCategoryEquivalence.inverse_obj_ρ_apply
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def inverse : (SingleObj G ⥤ V) ⥤ Action V G 
goal: (Action.FunctorCategoryEquivalence.inverse.obj F).ρ g = F.map g

full_name: Action.FunctorCategoryEquivalence.inverse
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def inverse : (SingleObj G ⥤ V) ⥤ Action V G 
goal: (CategoryTheory.SingleObj ↑G ⥤ V) ⥤ Action V G

full_name: Action.FunctorCategoryEquivalence.inverse_obj_V
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps]
def inverse : (SingleObj G ⥤ V) ⥤ Action V G 
goal: (Action.FunctorCategoryEquivalence.inverse.obj F).V = F.obj PUnit.unit

full_name: Action.FunctorCategoryEquivalence.unitIso
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def unitIso : 𝟭 (Action V G) ≅ functor ⋙ inverse 
goal: 𝟭 (Action V G) ≅ Action.FunctorCategoryEquivalence.functor ⋙ Action.FunctorCategoryEquivalence.inverse

full_name: Action.FunctorCategoryEquivalence.unitIso_inv_app_hom
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def unitIso : 𝟭 (Action V G) ≅ functor ⋙ inverse 
goal: (Action.FunctorCategoryEquivalence.unitIso.inv.app X).hom = 𝟙 X.V

full_name: Action.FunctorCategoryEquivalence.unitIso_hom_app_hom
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def unitIso : 𝟭 (Action V G) ≅ functor ⋙ inverse 
goal: (Action.FunctorCategoryEquivalence.unitIso.hom.app X).hom = 𝟙 X.V

full_name: Action.FunctorCategoryEquivalence.counitIso
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (SingleObj G ⥤ V) 
goal: Action.FunctorCategoryEquivalence.inverse ⋙ Action.FunctorCategoryEquivalence.functor ≅
  𝟭 (CategoryTheory.SingleObj ↑G ⥤ V)

full_name: Action.FunctorCategoryEquivalence.counitIso_inv_app_app
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (SingleObj G ⥤ V) 
goal: ∀ (X_1 : CategoryTheory.SingleObj ↑G),
  (Action.FunctorCategoryEquivalence.counitIso.inv.app X).app X_1 = 𝟙 (X.obj PUnit.unit)

full_name: Action.FunctorCategoryEquivalence.counitIso_hom_app_app
code: /-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (SingleObj G ⥤ V) 
goal: ∀ (X_1 : CategoryTheory.SingleObj ↑G),
  (Action.FunctorCategoryEquivalence.counitIso.hom.app X).app X_1 = 𝟙 (X.obj PUnit.unit)

full_name: Action.functorCategoryEquivalence_functor
code: /-- The category of actions of `G` in the category `V`
is equivalent to the functor category `singleObj G ⥤ V`.
-/
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
goal: (Action.functorCategoryEquivalence V G).functor = Action.FunctorCategoryEquivalence.functor

full_name: Action.functorCategoryEquivalence_inverse
code: /-- The category of actions of `G` in the category `V`
is equivalent to the functor category `singleObj G ⥤ V`.
-/
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
goal: (Action.functorCategoryEquivalence V G).inverse = Action.FunctorCategoryEquivalence.inverse

full_name: Action.functorCategoryEquivalence_counitIso
code: /-- The category of actions of `G` in the category `V`
is equivalent to the functor category `singleObj G ⥤ V`.
-/
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
goal: (Action.functorCategoryEquivalence V G).counitIso = Action.FunctorCategoryEquivalence.counitIso

full_name: Action.functorCategoryEquivalence
code: /-- The category of actions of `G` in the category `V`
is equivalent to the functor category `singleObj G ⥤ V`.
-/
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
goal: Action V G ≌ CategoryTheory.SingleObj ↑G ⥤ V

full_name: Action.functorCategoryEquivalence_unitIso
code: /-- The category of actions of `G` in the category `V`
is equivalent to the functor category `singleObj G ⥤ V`.
-/
@[simps]
def functorCategoryEquivalence : Action V G ≌ SingleObj G ⥤ V 
goal: (Action.functorCategoryEquivalence V G).unitIso = Action.FunctorCategoryEquivalence.unitIso

full_name: Action.forget
code: /-- (implementation) The forgetful functor from bundled actions to the underlying objects.

Use the `CategoryTheory.forget` API provided by the `ConcreteCategory` instance below,
rather than using this directly.
-/
@[simps]
def forget : Action V G ⥤ V 
goal: Action V G ⥤ V

full_name: Action.forget_obj
code: /-- (implementation) The forgetful functor from bundled actions to the underlying objects.

Use the `CategoryTheory.forget` API provided by the `ConcreteCategory` instance below,
rather than using this directly.
-/
@[simps]
def forget : Action V G ⥤ V 
goal: (Action.forget V G).obj M = M.V

full_name: Action.forget_map
code: /-- (implementation) The forgetful functor from bundled actions to the underlying objects.

Use the `CategoryTheory.forget` API provided by the `ConcreteCategory` instance below,
rather than using this directly.
-/
@[simps]
def forget : Action V G ⥤ V 
goal: ∀ {X Y : Action V G} (f : X ⟶ Y), (Action.forget V G).map f = f.hom

full_name: Action.instFaithfulForget
code: instance : (forget V G).Faithful 
goal: (Action.forget V G).Faithful

full_name: Action.instConcreteCategory
code: instance [ConcreteCategory V] : ConcreteCategory (Action V G) 
goal: CategoryTheory.ConcreteCategory (Action V G)

full_name: Action.hasForgetToV
code: instance hasForgetToV [ConcreteCategory V] : HasForget₂ (Action V G) V 
goal: CategoryTheory.HasForget₂ (Action V G) V

full_name: Action.functorCategoryEquivalenceCompEvaluation
code: /-- The forgetful functor is intertwined by `functorCategoryEquivalence` with
evaluation at `PUnit.star`. -/
def functorCategoryEquivalenceCompEvaluation :
    (functorCategoryEquivalence V G).functor ⋙ (evaluation _ _).obj PUnit.unit ≅ forget V G 
goal: (Action.functorCategoryEquivalence V G).functor ⋙
    (CategoryTheory.evaluation (CategoryTheory.SingleObj ↑G) V).obj PUnit.unit ≅
  Action.forget V G

full_name: Action.instPreservesLimitsForget
code: noncomputable instance instPreservesLimitsForget [HasLimits V] :
    Limits.PreservesLimits (forget V G) 
goal: CategoryTheory.Limits.PreservesLimits (Action.forget V G)

full_name: Action.instPreservesColimitsForget
code: noncomputable instance instPreservesColimitsForget [HasColimits V] :
    PreservesColimits (forget V G) 
goal: CategoryTheory.Limits.PreservesColimits (Action.forget V G)

full_name: Action.Iso.conj_ρ
code: theorem Iso.conj_ρ {M N : Action V G} (f : M ≅ N) (g : G) :
    N.ρ g = ((forget V G).mapIso f).conj (M.ρ g) 
goal: N.ρ g = ((Action.forget V G).mapIso f).conj (M.ρ g)

full_name: Action.actionPunitEquivalence
code: /-- Actions/representations of the trivial group are just objects in the ambient category. -/
def actionPunitEquivalence : Action V (MonCat.of PUnit) ≌ V 
goal: Action V (MonCat.of PUnit.{u + 1}) ≌ V

full_name: Action.res_obj_V
code: /-- The "restriction" functor along a monoid homomorphism `f : G ⟶ H`,
taking actions of `H` to actions of `G`.

(This makes sense for any homomorphism, but the name is natural when `f` is a monomorphism.)
-/
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
goal: ((Action.res V f).obj M).V = M.V

full_name: Action.res
code: /-- The "restriction" functor along a monoid homomorphism `f : G ⟶ H`,
taking actions of `H` to actions of `G`.

(This makes sense for any homomorphism, but the name is natural when `f` is a monomorphism.)
-/
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
goal: Action V H ⥤ Action V G

full_name: Action.res_map_hom
code: /-- The "restriction" functor along a monoid homomorphism `f : G ⟶ H`,
taking actions of `H` to actions of `G`.

(This makes sense for any homomorphism, but the name is natural when `f` is a monomorphism.)
-/
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
goal: ∀ {X Y : Action V H} (p : X ⟶ Y), ((Action.res V f).map p).hom = p.hom

full_name: Action.res_obj_ρ
code: /-- The "restriction" functor along a monoid homomorphism `f : G ⟶ H`,
taking actions of `H` to actions of `G`.

(This makes sense for any homomorphism, but the name is natural when `f` is a monomorphism.)
-/
@[simps]
def res {G H : MonCat} (f : G ⟶ H) : Action V H ⥤ Action V G 
goal: ((Action.res V f).obj M).ρ = f ≫ M.ρ

full_name: Action.resId_inv_app_hom
code: /-- The natural isomorphism from restriction along the identity homomorphism to
the identity functor on `Action V G`.
-/
@[simps!]
def resId {G : MonCat} : res V (𝟙 G) ≅ 𝟭 (Action V G) 
goal: ((Action.resId V).inv.app X).hom = 𝟙 X.V

full_name: Action.resId
code: /-- The natural isomorphism from restriction along the identity homomorphism to
the identity functor on `Action V G`.
-/
@[simps!]
def resId {G : MonCat} : res V (𝟙 G) ≅ 𝟭 (Action V G) 
goal: Action.res V (𝟙 G) ≅ 𝟭 (Action V G)

full_name: Action.resId_hom_app_hom
code: /-- The natural isomorphism from restriction along the identity homomorphism to
the identity functor on `Action V G`.
-/
@[simps!]
def resId {G : MonCat} : res V (𝟙 G) ≅ 𝟭 (Action V G) 
goal: ((Action.resId V).hom.app X).hom = 𝟙 X.V

full_name: Action.resComp_inv_app_hom
code: /-- The natural isomorphism from the composition of restrictions along homomorphisms
to the restriction along the composition of homomorphism.
-/
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g) 
goal: ((Action.resComp V f g).inv.app X).hom = 𝟙 X.V

full_name: Action.resComp
code: /-- The natural isomorphism from the composition of restrictions along homomorphisms
to the restriction along the composition of homomorphism.
-/
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g) 
goal: Action.res V g ⋙ Action.res V f ≅ Action.res V (f ≫ g)

full_name: Action.resComp_hom_app_hom
code: /-- The natural isomorphism from the composition of restrictions along homomorphisms
to the restriction along the composition of homomorphism.
-/
@[simps!]
def resComp {G H K : MonCat} (f : G ⟶ H) (g : H ⟶ K) : res V g ⋙ res V f ≅ res V (f ≫ g) 
goal: ((Action.resComp V f g).hom.app X).hom = 𝟙 X.V

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

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

full_name: CategoryTheory.Functor.mapAction_obj_ρ_apply
code: /-- 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 
goal: ((F.mapAction G).obj M).ρ g = F.map (M.ρ g)

full_name: CategoryTheory.Functor.mapAction_obj_V
code: /-- 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 
goal: ((F.mapAction G).obj M).V = F.obj M.V