Categorical properties of Action V G

We show:

• When V has (co)limits so does Action V G.
• When V is preadditive, linear, or abelian so is Action V G.

instance Action.instHasFiniteProducts {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteProducts V] : CategoryTheory.Limits.HasFiniteProducts (Action V G)

instance Action.instHasFiniteLimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteLimits V] : CategoryTheory.Limits.HasFiniteLimits (Action V G)

instance Action.instHasLimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasLimits V] : CategoryTheory.Limits.HasLimits (Action V G)

instance Action.hasLimitsOfShape {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] [CategoryTheory.Limits.HasLimitsOfShape J V] : CategoryTheory.Limits.HasLimitsOfShape J (Action V G)

If V has limits of shape J, so does Action V G.

instance Action.instHasFiniteCoproducts {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteCoproducts V] : CategoryTheory.Limits.HasFiniteCoproducts (Action V G)

instance Action.instHasFiniteColimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteColimits V] : CategoryTheory.Limits.HasFiniteColimits (Action V G)

instance Action.instHasColimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasColimits V] : CategoryTheory.Limits.HasColimits (Action V G)

instance Action.hasColimitsOfShape {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] [CategoryTheory.Limits.HasColimitsOfShape J V] : CategoryTheory.Limits.HasColimitsOfShape J (Action V G)

If V has colimits of shape J, so does Action V G.

theorem Action.preservesLimit_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (K : CategoryTheory.Functor J C) (h : CategoryTheory.Limits.PreservesLimit K (F.comp (forget V G))) : CategoryTheory.Limits.PreservesLimit K F

F : C ⥤ Action V G preserves the limit of some K : J ⥤ C if if it does after postcomposing with the forgetful functor Action V G ⥤ V.

theorem Action.preservesLimitsOfShape_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (h : CategoryTheory.Limits.PreservesLimitsOfShape J (F.comp (forget V G))) : CategoryTheory.Limits.PreservesLimitsOfShape J F

F : C ⥤ Action V G preserves limits of some shape J if it does after postcomposing with the forgetful functor Action V G ⥤ V.

theorem Action.preservesLimitsOfSize_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) (h : CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} (F.comp (forget V G))) : CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} F

F : C ⥤ Action V G preserves limits of some size if it does after postcomposing with the forgetful functor Action V G ⥤ V.

theorem Action.preservesColimit_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (K : CategoryTheory.Functor J C) (h : CategoryTheory.Limits.PreservesColimit K (F.comp (forget V G))) : CategoryTheory.Limits.PreservesColimit K F

F : C ⥤ Action V G preserves the colimit of some K : J ⥤ C if if it does after postcomposing with the forgetful functor Action V G ⥤ V.

theorem Action.preservesColimitsOfShape_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (h : CategoryTheory.Limits.PreservesColimitsOfShape J (F.comp (forget V G))) : CategoryTheory.Limits.PreservesColimitsOfShape J F

F : C ⥤ Action V G preserves colimits of some shape J if it does after postcomposing with the forgetful functor Action V G ⥤ V.

theorem Action.preservesColimitsOfSize_of_preserves {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {C : Type t₁} [CategoryTheory.Category.{t₂, t₁} C] (F : CategoryTheory.Functor C (Action V G)) (h : CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} (F.comp (forget V G))) : CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} F

F : C ⥤ Action V G preserves colimits of some size if it does after postcomposing with the forgetful functor Action V G ⥤ V.

instance Action.instPreservesLimitsOfShapeForgetOfHasLimitsOfShape {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] [CategoryTheory.Limits.HasLimitsOfShape J V] : CategoryTheory.Limits.PreservesLimitsOfShape J (forget V G)

instance Action.instPreservesColimitsOfShapeForgetOfHasColimitsOfShape {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] [CategoryTheory.Limits.HasColimitsOfShape J V] : CategoryTheory.Limits.PreservesColimitsOfShape J (forget V G)

instance Action.instPreservesFiniteLimitsForgetOfHasFiniteLimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteLimits V] : CategoryTheory.Limits.PreservesFiniteLimits (forget V G)

instance Action.instPreservesFiniteColimitsForgetOfHasFiniteColimits {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasFiniteColimits V] : CategoryTheory.Limits.PreservesFiniteColimits (forget V G)

instance Action.instReflectsLimitForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (F : CategoryTheory.Functor J (Action V G)) : CategoryTheory.Limits.ReflectsLimit F (forget V G)

instance Action.instReflectsLimitsOfShapeForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] : CategoryTheory.Limits.ReflectsLimitsOfShape J (forget V G)

instance Action.instReflectsLimitsForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] : CategoryTheory.Limits.ReflectsLimits (forget V G)

instance Action.instReflectsColimitForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] (F : CategoryTheory.Functor J (Action V G)) : CategoryTheory.Limits.ReflectsColimit F (forget V G)

instance Action.instReflectsColimitsOfShapeForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] {J : Type w₁} [CategoryTheory.Category.{w₂, w₁} J] : CategoryTheory.Limits.ReflectsColimitsOfShape J (forget V G)

instance Action.instReflectsColimitsForget {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] : CategoryTheory.Limits.ReflectsColimits (forget V G)

instance Action.instZeroHom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] {X Y : Action V G} : Zero (X ⟶ Y)

Equations

• Action.instZeroHom = { zero := { hom := 0, comm := ⋯ } }

@[simp]

theorem Action.zero_hom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] {X Y : Action V G} : Hom.hom 0 = 0

instance Action.instHasZeroMorphisms {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] : CategoryTheory.Limits.HasZeroMorphisms (Action V G)

Equations

• Action.instHasZeroMorphisms = CategoryTheory.Limits.HasZeroMorphisms.mk ⋯ ⋯

instance Action.forget_preservesZeroMorphisms {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] : (forget V G).PreservesZeroMorphisms

instance Action.forget₂_preservesZeroMorphisms {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] [CategoryTheory.HasForget V] : (CategoryTheory.forget₂ (Action V G) V).PreservesZeroMorphisms

instance Action.functorCategoryEquivalence_preservesZeroMorphisms {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] : (functorCategoryEquivalence V G).functor.PreservesZeroMorphisms

instance Action.instAddHom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} : Add (X ⟶ Y)

Equations

• Action.instAddHom = { add := fun (f g : X ⟶ Y) => { hom := f.hom + g.hom, comm := ⋯ } }

instance Action.instNegHom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} : Neg (X ⟶ Y)

Equations

• Action.instNegHom = { neg := fun (f : X ⟶ Y) => { hom := -f.hom, comm := ⋯ } }

instance Action.instPreadditive {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] : CategoryTheory.Preadditive (Action V G)

Equations

• Action.instPreadditive = { homGroup := fun (X Y : Action V G) => AddCommGroup.mk ⋯, add_comp := ⋯, comp_add := ⋯ }

instance Action.forget_additive {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] : (forget V G).Additive

instance Action.forget₂_additive {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] [CategoryTheory.HasForget V] : (CategoryTheory.forget₂ (Action V G) V).Additive

instance Action.functorCategoryEquivalence_additive {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] : (functorCategoryEquivalence V G).functor.Additive

@[simp]

theorem Action.neg_hom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (f : X ⟶ Y) : (-f).hom = -f.hom

@[simp]

theorem Action.add_hom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (f g : X ⟶ Y) : (f + g).hom = f.hom + g.hom

@[simp]

theorem Action.sum_hom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} {ι : Type u_1} (f : ι → (X ⟶ Y)) (s : Finset ι) : (s.sum f).hom = ∑ i ∈ s, (f i).hom

instance Action.instLinear {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Linear R (Action V G)

Equations

• Action.instLinear = { homModule := fun (X Y : Action V G) => Module.mk ⋯ ⋯, smul_comp := ⋯, comp_smul := ⋯ }

instance Action.forget_linear {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Functor.Linear R (forget V G)

instance Action.forget₂_linear {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] [CategoryTheory.HasForget V] : CategoryTheory.Functor.Linear R (CategoryTheory.forget₂ (Action V G) V)

instance Action.functorCategoryEquivalence_linear {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Functor.Linear R (functorCategoryEquivalence V G).functor

@[simp]

theorem Action.smul_hom {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] {X Y : Action V G} (r : R) (f : X ⟶ Y) : (r • f).hom = r • f.hom

instance Action.res_additive {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {H : Type u} [Monoid H] (f : G →* H) : (res V f).Additive

instance Action.res_linear {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] {H : Type u} [Monoid H] (f : G →* H) : CategoryTheory.Functor.Linear R (res V f)

def Action.abelianAux {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] : Action V G ≌ CategoryTheory.Functor (ULift.{u, 0} (CategoryTheory.SingleObj G)) V

Auxiliary construction for the Abelian (Action V G) instance.

Equations

• Action.abelianAux = (Action.functorCategoryEquivalence V G).trans CategoryTheory.ULift.equivalence.congrLeft

noncomputable instance Action.instAbelian {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : Type u} [Monoid G] [CategoryTheory.Abelian V] : CategoryTheory.Abelian (Action V G)

Equations

• Action.instAbelian = CategoryTheory.abelianOfEquivalence Action.abelianAux.functor

instance CategoryTheory.Functor.mapAction_preadditive {V : Type (u + 1)} [LargeCategory V] {W : Type (u + 1)} [LargeCategory W] (F : Functor V W) (G : Type u) [Monoid G] [Preadditive V] [Preadditive W] [F.Additive] : (F.mapAction G).Additive

instance CategoryTheory.Functor.mapAction_linear {V : Type (u + 1)} [LargeCategory V] {W : Type (u + 1)} [LargeCategory W] (F : Functor V W) (G : Type u) [Monoid G] [Preadditive V] [Preadditive W] {R : Type u_1} [Semiring R] [CategoryTheory.Linear R V] [CategoryTheory.Linear R W] [Linear R F] : Linear R (F.mapAction G)