Action V G, the category of actions of a monoid G inside some category V.

The prototypical example is V = ModuleCat R, where Action (ModuleCat R) G is the category of R-linear representations of G.

We check Action V G ≌ (CategoryTheory.singleObj G ⥤ V), and construct the restriction functors res {G H} [Monoid G] [Monoid H] (f : G →* H) : Action V H ⥤ Action V G.

structure Action (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : Type (max (max u_1 u_2) u_3)

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.

• V : V

  The object this action acts on

• ρ : G →* CategoryTheory.End self.V

  The underlying monoid homomorphism of this action

theorem Action.ρ_one {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (A : Action V G) : A.ρ 1 = CategoryTheory.CategoryStruct.id A.V

def Action.ρAut {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Group G] (A : Action V G) : G →* CategoryTheory.Aut A.V

When a group acts, we can lift the action to the group of automorphisms.

Equations

• A.ρAut = { toFun := fun (g : G) => { hom := A.ρ g, inv := A.ρ g⁻¹, hom_inv_id := ⋯, inv_hom_id := ⋯ }, map_one' := ⋯, map_mul' := ⋯ }

@[simp]

theorem Action.ρAut_apply_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Group G] (A : Action V G) (g : G) : (A.ρAut g).hom = A.ρ g

@[simp]

theorem Action.ρAut_apply_inv {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Group G] (A : Action V G) (g : G) : (A.ρAut g).inv = A.ρ g⁻¹

instance Action.inhabited' (G : Type u_2) [Monoid G] : Inhabited (Action (Type u_3) G)

Equations

• Action.inhabited' G = { default := { V := PUnit.{?u.10 + 1}, ρ := 1 } }

def Action.trivial (G : Type u_2) [Monoid G] : Action AddCommGrp G

The trivial representation of a group.

Equations

• Action.trivial G = { V := AddCommGrp.of PUnit.{?u.10 + 1}, ρ := 1 }

instance Action.instInhabitedAddCommGrp (G : Type u_2) [Monoid G] : Inhabited (Action AddCommGrp G)

Equations

• Action.instInhabitedAddCommGrp G = { default := Action.trivial G }

structure Action.Hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M N : Action V G) : Type u_3

A homomorphism of Action V Gs is a morphism between the underlying objects, commuting with the action of G.

• hom : M.V ⟶ N.V

  The morphism between the underlying objects of this action

• comm (g : G) : CategoryTheory.CategoryStruct.comp (M.ρ g) self.hom = CategoryTheory.CategoryStruct.comp self.hom (N.ρ g)

theorem Action.Hom.ext_iff {V : Type u_1} {inst✝ : CategoryTheory.Category.{u_3, u_1} V} {G : Type u_2} {inst✝¹ : Monoid G} {M N : Action V G} {x y : M.Hom N} : x = y ↔ x.hom = y.hom

theorem Action.Hom.ext {V : Type u_1} {inst✝ : CategoryTheory.Category.{u_3, u_1} V} {G : Type u_2} {inst✝¹ : Monoid G} {M N : Action V G} {x y : M.Hom N} (hom : x.hom = y.hom) : x = y

theorem Action.Hom.comm_assoc {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (self : M.Hom N) (g : G) {Z : V} (h : N.V ⟶ Z) : CategoryTheory.CategoryStruct.comp (M.ρ g) (CategoryTheory.CategoryStruct.comp self.hom h) = CategoryTheory.CategoryStruct.comp self.hom (CategoryTheory.CategoryStruct.comp (N.ρ g) h)

def Action.Hom.id {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) : M.Hom M

The identity morphism on an Action V G.

Equations

• Action.Hom.id M = { hom := CategoryTheory.CategoryStruct.id M.V, comm := ⋯ }

@[simp]

theorem Action.Hom.id_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) : (id M).hom = CategoryTheory.CategoryStruct.id M.V

instance Action.Hom.instInhabited {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) : Inhabited (M.Hom M)

Equations

• Action.Hom.instInhabited M = { default := Action.Hom.id M }

def Action.Hom.comp {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N K : Action V G} (p : M.Hom N) (q : N.Hom K) : M.Hom K

The composition of two Action V G homomorphisms is the composition of the underlying maps.

Equations

• p.comp q = { hom := CategoryTheory.CategoryStruct.comp p.hom q.hom, comm := ⋯ }

@[simp]

theorem Action.Hom.comp_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N K : Action V G} (p : M.Hom N) (q : N.Hom K) : (p.comp q).hom = CategoryTheory.CategoryStruct.comp p.hom q.hom

instance Action.instCategory {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] : CategoryTheory.Category.{u_3, max (max u_3 u_2) u_1} (Action V G)

Equations

• One or more equations did not get rendered due to their size.

theorem Action.hom_ext {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (φ₁ φ₂ : M ⟶ N) (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂

theorem Action.hom_ext_iff {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} {φ₁ φ₂ : M ⟶ N} : φ₁ = φ₂ ↔ φ₁.hom = φ₂.hom

@[simp]

theorem Action.id_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) : (CategoryTheory.CategoryStruct.id M).hom = CategoryTheory.CategoryStruct.id M.V

@[simp]

theorem Action.comp_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N K : Action V G} (f : M ⟶ N) (g : N ⟶ K) : (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom

@[simp]

theorem Action.hom_inv_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ≅ N) : CategoryTheory.CategoryStruct.comp f.hom.hom f.inv.hom = CategoryTheory.CategoryStruct.id M.V

@[simp]

theorem Action.inv_hom_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ≅ N) : CategoryTheory.CategoryStruct.comp f.inv.hom f.hom.hom = CategoryTheory.CategoryStruct.id N.V

def Action.mkIso {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M.V ≅ N.V) (comm : ∀ (g : G), CategoryTheory.CategoryStruct.comp (M.ρ g) f.hom = CategoryTheory.CategoryStruct.comp f.hom (N.ρ g) := by aesop_cat) : M ≅ N

Construct an isomorphism of G actions/representations from an isomorphism of the underlying objects, where the forward direction commutes with the group action.

Equations

• Action.mkIso f comm = { hom := { hom := f.hom, comm := comm }, inv := { hom := f.inv, comm := ⋯ }, hom_inv_id := ⋯, inv_hom_id := ⋯ }

@[simp]

theorem Action.mkIso_inv_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M.V ≅ N.V) (comm : ∀ (g : G), CategoryTheory.CategoryStruct.comp (M.ρ g) f.hom = CategoryTheory.CategoryStruct.comp f.hom (N.ρ g) := by aesop_cat) : (mkIso f comm).inv.hom = f.inv

@[simp]

theorem Action.mkIso_hom_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M.V ≅ N.V) (comm : ∀ (g : G), CategoryTheory.CategoryStruct.comp (M.ρ g) f.hom = CategoryTheory.CategoryStruct.comp f.hom (N.ρ g) := by aesop_cat) : (mkIso f comm).hom.hom = f.hom

@[instance 100]

instance Action.isIso_of_hom_isIso {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ⟶ N) [CategoryTheory.IsIso f.hom] : CategoryTheory.IsIso f

instance Action.isIso_hom_mk {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M.V ⟶ N.V) [CategoryTheory.IsIso f] (w : ∀ (g : G), CategoryTheory.CategoryStruct.comp (M.ρ g) f = CategoryTheory.CategoryStruct.comp f (N.ρ g)) : CategoryTheory.IsIso { hom := f, comm := w }

instance Action.instIsIsoHomHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ≅ N) : CategoryTheory.IsIso f.hom.hom

instance Action.instIsIsoHomInv {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ≅ N) : CategoryTheory.IsIso f.inv.hom

def Action.FunctorCategoryEquivalence.functor {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] : CategoryTheory.Functor (Action V G) (CategoryTheory.Functor (CategoryTheory.SingleObj G) V)

Auxiliary definition for functorCategoryEquivalence.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.FunctorCategoryEquivalence.functor_obj_map {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) {X✝ Y✝ : CategoryTheory.SingleObj G} (g : X✝ ⟶ Y✝) : (functor.obj M).map g = M.ρ g

@[simp]

theorem Action.FunctorCategoryEquivalence.functor_obj_obj {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (M : Action V G) (x✝ : CategoryTheory.SingleObj G) : (functor.obj M).obj x✝ = M.V

@[simp]

theorem Action.FunctorCategoryEquivalence.functor_map_app {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {X✝ Y✝ : Action V G} (f : X✝ ⟶ Y✝) (x✝ : CategoryTheory.SingleObj G) : (functor.map f).app x✝ = f.hom

def Action.FunctorCategoryEquivalence.inverse {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] : CategoryTheory.Functor (CategoryTheory.Functor (CategoryTheory.SingleObj G) V) (Action V G)

Auxiliary definition for functorCategoryEquivalence.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.FunctorCategoryEquivalence.inverse_obj_ρ_apply {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (F : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) (g : G) : (inverse.obj F).ρ g = F.map g

@[simp]

theorem Action.FunctorCategoryEquivalence.inverse_obj_V {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (F : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) : (inverse.obj F).V = F.obj PUnit.unit

@[simp]

theorem Action.FunctorCategoryEquivalence.inverse_map_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {X✝ Y✝ : CategoryTheory.Functor (CategoryTheory.SingleObj G) V} (f : X✝ ⟶ Y✝) : (inverse.map f).hom = f.app PUnit.unit

def Action.FunctorCategoryEquivalence.unitIso {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] : CategoryTheory.Functor.id (Action V G) ≅ functor.comp inverse

Auxiliary definition for functorCategoryEquivalence.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.FunctorCategoryEquivalence.unitIso_hom_app_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (X : Action V G) : (unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.V

@[simp]

theorem Action.FunctorCategoryEquivalence.unitIso_inv_app_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (X : Action V G) : (unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.V

def Action.FunctorCategoryEquivalence.counitIso {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] : inverse.comp functor ≅ CategoryTheory.Functor.id (CategoryTheory.Functor (CategoryTheory.SingleObj G) V)

Auxiliary definition for functorCategoryEquivalence.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.FunctorCategoryEquivalence.counitIso_inv_app_app {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (X : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) (X✝ : CategoryTheory.SingleObj G) : (counitIso.inv.app X).app X✝ = CategoryTheory.CategoryStruct.id (X.obj PUnit.unit)

@[simp]

theorem Action.FunctorCategoryEquivalence.counitIso_hom_app_app {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] (X : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) (X✝ : CategoryTheory.SingleObj G) : (counitIso.hom.app X).app X✝ = CategoryTheory.CategoryStruct.id (X.obj PUnit.unit)

def Action.functorCategoryEquivalence (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : Action V G ≌ CategoryTheory.Functor (CategoryTheory.SingleObj G) V

The category of actions of G in the category V is equivalent to the functor category singleObj G ⥤ V.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.functorCategoryEquivalence_inverse (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (functorCategoryEquivalence V G).inverse = FunctorCategoryEquivalence.inverse

@[simp]

theorem Action.functorCategoryEquivalence_functor (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (functorCategoryEquivalence V G).functor = FunctorCategoryEquivalence.functor

@[simp]

theorem Action.functorCategoryEquivalence_counitIso (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (functorCategoryEquivalence V G).counitIso = FunctorCategoryEquivalence.counitIso

@[simp]

theorem Action.functorCategoryEquivalence_unitIso (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (functorCategoryEquivalence V G).unitIso = FunctorCategoryEquivalence.unitIso

instance Action.instIsEquivalenceFunctorSingleObjFunctor (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : FunctorCategoryEquivalence.functor.IsEquivalence

instance Action.instIsEquivalenceFunctorSingleObjInverse (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : FunctorCategoryEquivalence.inverse.IsEquivalence

def Action.forget (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : CategoryTheory.Functor (Action V G) V

(implementation) The forgetful functor from bundled actions to the underlying objects.

Use the CategoryTheory.forget API provided by the HasForget instance below, rather than using this directly.

Equations

• Action.forget V G = { obj := fun (M : Action V G) => M.V, map := fun {X Y : Action V G} (f : X ⟶ Y) => f.hom, map_id := ⋯, map_comp := ⋯ }

@[simp]

theorem Action.forget_obj (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] (M : Action V G) : (forget V G).obj M = M.V

@[simp]

theorem Action.forget_map (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] {X✝ Y✝ : Action V G} (f : X✝ ⟶ Y✝) : (forget V G).map f = f.hom

instance Action.instFaithfulForget (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (forget V G).Faithful

instance Action.instHasForget (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] [CategoryTheory.HasForget V] : CategoryTheory.HasForget (Action V G)

Equations

• Action.instHasForget V G = { forget := (Action.forget V G).comp CategoryTheory.HasForget.forget, forget_faithful := ⋯ }

@[reducible, inline]

abbrev Action.HomSubtype (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] (G : Type u_2) [Monoid G] {FV : V → V → Type u_3} {CV : V → Type u_4} [(X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] [CategoryTheory.ConcreteCategory V FV] (M N : Action V G) : Type u_3

The type of V-morphisms that can be lifted back to morphisms in the category Action.

Equations

• Action.HomSubtype V G M N = { f : FV M.V N.V // ∀ (g : G), ⇑f ∘ ⇑(CategoryTheory.ConcreteCategory.hom (M.ρ g)) = ⇑(CategoryTheory.ConcreteCategory.hom (N.ρ g)) ∘ ⇑f }

instance Action.instFunLikeHomSubtypeV (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] (G : Type u_2) [Monoid G] {FV : V → V → Type u_3} {CV : V → Type u_4} [(X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] [CategoryTheory.ConcreteCategory V FV] (M N : Action V G) : FunLike (HomSubtype V G M N) (CV M.V) (CV N.V)

Equations

• Action.instFunLikeHomSubtypeV V G M N = { coe := fun (f : Action.HomSubtype V G M N) => ⇑↑f, coe_injective' := ⋯ }

instance Action.instConcreteCategoryHomSubtypeV (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] (G : Type u_2) [Monoid G] {FV : V → V → Type u_3} {CV : V → Type u_4} [(X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] [CategoryTheory.ConcreteCategory V FV] : CategoryTheory.ConcreteCategory (Action V G) (HomSubtype V G)

Equations

• One or more equations did not get rendered due to their size.

instance Action.hasForgetToV (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] [CategoryTheory.HasForget V] : CategoryTheory.HasForget₂ (Action V G) V

Equations

• Action.hasForgetToV V G = { forget₂ := Action.forget V G, forget_comp := ⋯ }

def Action.functorCategoryEquivalenceCompEvaluation (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] : (functorCategoryEquivalence V G).functor.comp ((CategoryTheory.evaluation (CategoryTheory.SingleObj G) V).obj PUnit.unit) ≅ forget V G

The forgetful functor is intertwined by functorCategoryEquivalence with evaluation at PUnit.star.

Equations

• One or more equations did not get rendered due to their size.

instance Action.preservesLimits_forget (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] [CategoryTheory.Limits.HasLimits V] : CategoryTheory.Limits.PreservesLimits (forget V G)

instance Action.preservesColimits_forget (V : Type u_1) [CategoryTheory.Category.{u_3, u_1} V] (G : Type u_2) [Monoid G] [CategoryTheory.Limits.HasColimits V] : CategoryTheory.Limits.PreservesColimits (forget V G)

theorem Action.Iso.conj_ρ {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] {M N : Action V G} (f : M ≅ N) (g : G) : N.ρ g = ((forget V G).mapIso f).conj (M.ρ g)

def Action.actionPunitEquivalence {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] : Action V PUnit.{u_4 + 1} ≌ V

Actions/representations of the trivial group are just objects in the ambient category.

Equations

• One or more equations did not get rendered due to their size.

def Action.res (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) : CategoryTheory.Functor (Action V H) (Action V G)

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

Equations

• Action.res V f = { obj := fun (M : Action V H) => { V := M.V, ρ := M.ρ.comp f }, map := fun {X Y : Action V H} (p : X ⟶ Y) => { hom := p.hom, comm := ⋯ }, map_id := ⋯, map_comp := ⋯ }

@[simp]

theorem Action.res_obj_ρ (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) (M : Action V H) : ((res V f).obj M).ρ = M.ρ.comp f

@[simp]

theorem Action.res_obj_V (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) (M : Action V H) : ((res V f).obj M).V = M.V

@[simp]

theorem Action.res_map_hom (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) {X✝ Y✝ : Action V H} (p : X✝ ⟶ Y✝) : ((res V f).map p).hom = p.hom

def Action.resId (V : Type u_1) [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_3} [Monoid G] : res V (MonoidHom.id G) ≅ CategoryTheory.Functor.id (Action V G)

The natural isomorphism from restriction along the identity homomorphism to the identity functor on Action V G.

Equations

• Action.resId V = CategoryTheory.NatIso.ofComponents (fun (M : Action V G) => Action.mkIso (CategoryTheory.Iso.refl ((Action.res V (MonoidHom.id G)).obj M).V) ⋯) ⋯

@[simp]

theorem Action.resId_hom_app_hom (V : Type u_1) [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_3} [Monoid G] (X : Action V G) : ((resId V).hom.app X).hom = CategoryTheory.CategoryStruct.id X.V

@[simp]

theorem Action.resId_inv_app_hom (V : Type u_1) [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_3} [Monoid G] (X : Action V G) : ((resId V).inv.app X).hom = CategoryTheory.CategoryStruct.id X.V

def Action.resComp (V : Type u_1) [CategoryTheory.Category.{u_6, u_1} V] {G : Type u_3} {H : Type u_4} {K : Type u_5} [Monoid G] [Monoid H] [Monoid K] (f : G →* H) (g : H →* K) : (res V g).comp (res V f) ≅ res V (g.comp f)

The natural isomorphism from the composition of restrictions along homomorphisms to the restriction along the composition of homomorphism.

Equations

• Action.resComp V f g = CategoryTheory.NatIso.ofComponents (fun (M : Action V K) => Action.mkIso (CategoryTheory.Iso.refl (((Action.res V g).comp (Action.res V f)).obj M).V) ⋯) ⋯

@[simp]

theorem Action.resComp_inv_app_hom (V : Type u_1) [CategoryTheory.Category.{u_6, u_1} V] {G : Type u_3} {H : Type u_4} {K : Type u_5} [Monoid G] [Monoid H] [Monoid K] (f : G →* H) (g : H →* K) (X : Action V K) : ((resComp V f g).inv.app X).hom = CategoryTheory.CategoryStruct.id X.V

@[simp]

theorem Action.resComp_hom_app_hom (V : Type u_1) [CategoryTheory.Category.{u_6, u_1} V] {G : Type u_3} {H : Type u_4} {K : Type u_5} [Monoid G] [Monoid H] [Monoid K] (f : G →* H) (g : H →* K) (X : Action V K) : ((resComp V f g).hom.app X).hom = CategoryTheory.CategoryStruct.id X.V

def Action.resCongr (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] {f f' : G →* H} (h : f = f') : res V f ≅ res V f'

Restricting scalars along equal maps is naturally isomorphic.

Equations

• Action.resCongr V h = CategoryTheory.NatIso.ofComponents (fun (x : Action V H) => Action.mkIso (CategoryTheory.Iso.refl ((Action.res V f).obj x).V) ⋯) ⋯

@[simp]

theorem Action.resCongr_hom (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] {f f' : G →* H} (h : f = f') : (resCongr V h).hom = { app := fun (X : Action V H) => (mkIso (CategoryTheory.Iso.refl X.V) ⋯).hom, naturality := ⋯ }

@[simp]

theorem Action.resCongr_inv (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] {f f' : G →* H} (h : f = f') : (resCongr V h).inv = { app := fun (X : Action V H) => (mkIso (CategoryTheory.Iso.refl X.V) ⋯).inv, naturality := ⋯ }

def Action.resEquiv (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G ≃* H) : Action V H ≌ Action V G

Restricting scalars along a monoid isomorphism induces an equivalence of categories.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Action.resEquiv_inverse (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G ≃* H) : (resEquiv V f).inverse = res V ↑f.symm

@[simp]

theorem Action.resEquiv_functor (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G ≃* H) : (resEquiv V f).functor = res V ↑f

instance Action.instFaithfulRes (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) : (res V f).Faithful

The functor from Action V H to Action V G induced by a morphism f : G → H is faithful.

theorem Action.full_res (V : Type u_1) [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_3} {H : Type u_4} [Monoid G] [Monoid H] (f : G →* H) (f_surj : Function.Surjective ⇑f) : (res V f).Full

The functor from Action V H to Action V G induced by a morphism f : G → H is full if f is surjective.

def CategoryTheory.Functor.mapAction {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (F : Functor V W) (G : Type u_3) [Monoid G] : Functor (Action V G) (Action W G)

A functor between categories induces a functor between the categories of G-actions within those categories.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Functor.mapAction_obj_V {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (F : Functor V W) (G : Type u_3) [Monoid G] (M : Action V G) : ((F.mapAction G).obj M).V = F.obj M.V

@[simp]

theorem CategoryTheory.Functor.mapAction_obj_ρ_apply {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (F : Functor V W) (G : Type u_3) [Monoid G] (M : Action V G) (g : G) : ((F.mapAction G).obj M).ρ g = F.map (M.ρ g)

@[simp]

theorem CategoryTheory.Functor.mapAction_map_hom {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (F : Functor V W) (G : Type u_3) [Monoid G] {X✝ Y✝ : Action V G} (f : X✝ ⟶ Y✝) : ((F.mapAction G).map f).hom = F.map f.hom

def CategoryTheory.Functor.mapActionComp {V : Type u_1} [Category.{u_5, u_1} V] {W : Type u_2} [Category.{u_6, u_2} W] (G : Type u_3) [Monoid G] {T : Type u_4} [Category.{u_7, u_4} T] (F : Functor V W) (F' : Functor W T) : (F.comp F').mapAction G ≅ (F.mapAction G).comp (F'.mapAction G)

Functor.mapAction is functorial in the functor.

Equations

• CategoryTheory.Functor.mapActionComp G F F' = CategoryTheory.NatIso.ofComponents (fun (X : Action V G) => CategoryTheory.Iso.refl (((F.comp F').mapAction G).obj X)) ⋯

@[simp]

theorem CategoryTheory.Functor.mapActionComp_hom {V : Type u_1} [Category.{u_5, u_1} V] {W : Type u_2} [Category.{u_6, u_2} W] (G : Type u_3) [Monoid G] {T : Type u_4} [Category.{u_7, u_4} T] (F : Functor V W) (F' : Functor W T) : (mapActionComp G F F').hom = { app := fun (X : Action V G) => CategoryStruct.id (((F.comp F').mapAction G).obj X), naturality := ⋯ }

@[simp]

theorem CategoryTheory.Functor.mapActionComp_inv {V : Type u_1} [Category.{u_5, u_1} V] {W : Type u_2} [Category.{u_6, u_2} W] (G : Type u_3) [Monoid G] {T : Type u_4} [Category.{u_7, u_4} T] (F : Functor V W) (F' : Functor W T) : (mapActionComp G F F').inv = { app := fun (X : Action V G) => CategoryStruct.id (((F.comp F').mapAction G).obj X), naturality := ⋯ }

def CategoryTheory.Functor.mapActionCongr {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (G : Type u_3) [Monoid G] {F F' : Functor V W} (e : F ≅ F') : F.mapAction G ≅ F'.mapAction G

Functor.mapAction preserves isomorphisms of functors.

Equations

• CategoryTheory.Functor.mapActionCongr G e = CategoryTheory.NatIso.ofComponents (fun (X : Action V G) => Action.mkIso (e.app X.V) ⋯) ⋯

@[simp]

theorem CategoryTheory.Functor.mapActionCongr_inv {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (G : Type u_3) [Monoid G] {F F' : Functor V W} (e : F ≅ F') : (mapActionCongr G e).inv = { app := fun (X : Action V G) => (Action.mkIso (e.app X.V) ⋯).inv, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Functor.mapActionCongr_hom {V : Type u_1} [Category.{u_4, u_1} V] {W : Type u_2} [Category.{u_5, u_2} W] (G : Type u_3) [Monoid G] {F F' : Functor V W} (e : F ≅ F') : (mapActionCongr G e).hom = { app := fun (X : Action V G) => (Action.mkIso (e.app X.V) ⋯).hom, naturality := ⋯ }

def CategoryTheory.Equivalence.mapAction {V : Type u_2} {W : Type u_3} [Category.{u_5, u_2} V] [Category.{u_6, u_3} W] (G : Type u_4) [Monoid G] (E : V ≌ W) : Action V G ≌ Action W G

An equivalence of categories induces an equivalence of the categories of G-actions within those categories.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Equivalence.mapAction_inverse {V : Type u_2} {W : Type u_3} [Category.{u_5, u_2} V] [Category.{u_6, u_3} W] (G : Type u_4) [Monoid G] (E : V ≌ W) : (mapAction G E).inverse = E.inverse.mapAction G

@[simp]

theorem CategoryTheory.Equivalence.mapAction_functor {V : Type u_2} {W : Type u_3} [Category.{u_5, u_2} V] [Category.{u_6, u_3} W] (G : Type u_4) [Monoid G] (E : V ≌ W) : (mapAction G E).functor = E.functor.mapAction G