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.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasFiniteProducts V] : CategoryTheory.Limits.HasFiniteProducts (Action V G)

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

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

instance Action.hasLimitsOfShape {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} 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.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasFiniteCoproducts V] : CategoryTheory.Limits.HasFiniteCoproducts (Action V G)

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

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

instance Action.hasColimitsOfShape {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} 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.Category.{u_6, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_5, u_3} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type u_4} [CategoryTheory.Category.{u_7, u_4} 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.Category.{u_6, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_5, u_3} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type u_4} [CategoryTheory.Category.{u_7, u_4} 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.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_4, u_3} C] (F : CategoryTheory.Functor C (Action V G)) (h : CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, u_4, u_5, u_3, u_1} (F.comp (forget V G))) : CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, u_4, u_5, u_3, max (max u_1 u_2) u_5} 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.Category.{u_6, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_5, u_3} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type u_4} [CategoryTheory.Category.{u_7, u_4} 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.Category.{u_6, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_5, u_3} C] (F : CategoryTheory.Functor C (Action V G)) {J : Type u_4} [CategoryTheory.Category.{u_7, u_4} 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.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {C : Type u_3} [CategoryTheory.Category.{u_4, u_3} C] (F : CategoryTheory.Functor C (Action V G)) (h : CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, u_4, u_5, u_3, u_1} (F.comp (forget V G))) : CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, u_4, u_5, u_3, max (max u_1 u_2) u_5} 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.instPreservesLimitForgetOfHasLimitComp {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] (K : CategoryTheory.Functor J (Action V G)) [CategoryTheory.Limits.HasLimit (K.comp (forget V G))] : CategoryTheory.Limits.PreservesLimit K (forget V G)

Action.forget V G : Action V G ⥤ V preserves the limit of some K : J ⥤ Action V G if K ⋙ Action.forget V G has a limit.

instance Action.instPreservesLimitsOfShapeForgetOfHasLimitsOfShape {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] [CategoryTheory.Limits.HasLimitsOfShape J V] : CategoryTheory.Limits.PreservesLimitsOfShape J (forget V G)

instance Action.instPreservesColimitForgetOfHasColimitComp {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] (K : CategoryTheory.Functor J (Action V G)) [CategoryTheory.Limits.HasColimit (K.comp (forget V G))] : CategoryTheory.Limits.PreservesColimit K (forget V G)

Action.forget V G : Action V G ⥤ V preserves the colimit of some K : J ⥤ Action V G if K ⋙ Action.forget V G has a colimit.

instance Action.instPreservesColimitsOfShapeForgetOfHasColimitsOfShape {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] [CategoryTheory.Limits.HasColimitsOfShape J V] : CategoryTheory.Limits.PreservesColimitsOfShape J (forget V G)

instance Action.instPreservesFiniteLimitsForgetOfHasFiniteLimits {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasFiniteLimits V] : CategoryTheory.Limits.PreservesFiniteLimits (forget V G)

instance Action.instPreservesFiniteColimitsForgetOfHasFiniteColimits {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasFiniteColimits V] : CategoryTheory.Limits.PreservesFiniteColimits (forget V G)

instance Action.instReflectsLimitForget {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] (F : CategoryTheory.Functor J (Action V G)) : CategoryTheory.Limits.ReflectsLimit F (forget V G)

instance Action.instReflectsLimitsOfShapeForget {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] : CategoryTheory.Limits.ReflectsLimitsOfShape J (forget V G)

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

instance Action.instReflectsColimitForget {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] (F : CategoryTheory.Functor J (Action V G)) : CategoryTheory.Limits.ReflectsColimit F (forget V G)

instance Action.instReflectsColimitsOfShapeForget {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] {J : Type u_3} [CategoryTheory.Category.{u_4, u_3} J] : CategoryTheory.Limits.ReflectsColimitsOfShape J (forget V G)

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

instance Action.Functor.mapActionPreservesLimit_of_preserves {V : Type u_1} [CategoryTheory.Category.{u_7, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_8, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] {J : Type u_5} [CategoryTheory.Category.{u_6, u_5} J] (K : CategoryTheory.Functor J (Action V G)) [CategoryTheory.Limits.HasLimit (K.comp (forget V G))] [CategoryTheory.Limits.PreservesLimit (K.comp (forget V G)) F] : CategoryTheory.Limits.PreservesLimit K (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves the limit of some K : J ⥤ Action V G if K ⋙ forget V G has a limit and F preserves the limit of K ⋙ forget V G.

instance Action.Functor.mapActionPreservesLimitsOfShapeOfPreserves {V : Type u_1} [CategoryTheory.Category.{u_7, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_8, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] {J : Type u_5} [CategoryTheory.Category.{u_6, u_5} J] [CategoryTheory.Limits.PreservesLimitsOfShape J F] [CategoryTheory.Limits.HasLimitsOfShape J V] : CategoryTheory.Limits.PreservesLimitsOfShape J (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves limits of some shape J if V has limits of shape J and F preserves limits of shape J.

instance Action.Functor.preservesLimitsOfSize_of_preserves {V : Type u_1} [CategoryTheory.Category.{u_6, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_7, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] [CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, u_6, u_7, u_1, u_3} F] [CategoryTheory.Limits.HasLimitsOfSize.{w₂, w₁, u_6, u_1} V] : CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, u_6, u_7, max (max u_1 u_4) u_6, max (max u_3 u_4) u_7} (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves limits of some size if V has limits of that size and F preserves limits of that size.

instance Action.Functor.instPreservesFiniteLimitsMapActionOfHasFiniteLimits {V : Type u_1} [CategoryTheory.Category.{u_6, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_7, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] [CategoryTheory.Limits.PreservesFiniteLimits F] [CategoryTheory.Limits.HasFiniteLimits V] : CategoryTheory.Limits.PreservesFiniteLimits (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves finite limits if V has finite limits and F preserves finite limits.

instance Action.Functor.mapActionPreservesColimit_of_preserves {V : Type u_1} [CategoryTheory.Category.{u_7, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_8, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] {J : Type u_5} [CategoryTheory.Category.{u_6, u_5} J] (K : CategoryTheory.Functor J (Action V G)) [CategoryTheory.Limits.HasColimit (K.comp (forget V G))] [CategoryTheory.Limits.PreservesColimit (K.comp (forget V G)) F] : CategoryTheory.Limits.PreservesColimit K (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves the colimit of some K : J ⥤ Action V G if K ⋙ forget V G has a colimit and F preserves the colimit of K ⋙ forget V G.

instance Action.Functor.mapActionPreservesColimitsOfShapeOfPreserves {V : Type u_1} [CategoryTheory.Category.{u_7, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_8, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] {J : Type u_5} [CategoryTheory.Category.{u_6, u_5} J] [CategoryTheory.Limits.PreservesColimitsOfShape J F] [CategoryTheory.Limits.HasColimitsOfShape J V] : CategoryTheory.Limits.PreservesColimitsOfShape J (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves colimits of some shape J if V has colimits of shape J and F preserves colimits of shape J.

instance Action.Functor.preservesColimitsOfSize_of_preserves {V : Type u_1} [CategoryTheory.Category.{u_6, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_7, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] [CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, u_6, u_7, u_1, u_3} F] [CategoryTheory.Limits.HasColimitsOfSize.{w₂, w₁, u_6, u_1} V] : CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, u_6, u_7, max (max u_1 u_4) u_6, max (max u_3 u_4) u_7} (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves colimits of some size if V has colimits of that size and F preserves colimits of that size.

instance Action.Functor.instPreservesFiniteColimitsMapActionOfHasFiniteColimits {V : Type u_1} [CategoryTheory.Category.{u_6, u_1} V] {W : Type u_3} [CategoryTheory.Category.{u_7, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [Monoid G] [CategoryTheory.Limits.PreservesFiniteColimits F] [CategoryTheory.Limits.HasFiniteColimits V] : CategoryTheory.Limits.PreservesFiniteColimits (F.mapAction G)

F.mapAction : Action V G ⥤ Action W G preserves finite colimits if V has finite colimits and F preserves finite colimits.

instance Action.instZeroHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [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.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] {X Y : Action V G} : Hom.hom 0 = 0

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

Equations

• Action.instHasZeroMorphisms = { zero := fun (X Y : Action V G) => Action.instZeroHom, comp_zero := ⋯, zero_comp := ⋯ }

instance Action.forget_preservesZeroMorphisms {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] : (forget V G).PreservesZeroMorphisms

instance Action.forget₂_preservesZeroMorphisms {V : Type u_1} [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_2} [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.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Limits.HasZeroMorphisms V] : (functorCategoryEquivalence V G).functor.PreservesZeroMorphisms

instance Action.instAddHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [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.Category.{u_3, u_1} V] {G : Type u_2} [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.instSubHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} : Sub (X ⟶ Y)

Equations

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

instance Action.instSMulNatHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} : SMul ℕ (X ⟶ Y)

Equations

• Action.instSMulNatHom = { smul := fun (n : ℕ) (f : X ⟶ Y) => { hom := n • f.hom, comm := ⋯ } }

instance Action.instSMulIntHom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} : SMul ℤ (X ⟶ Y)

Equations

• Action.instSMulIntHom = { smul := fun (n : ℤ) (f : X ⟶ Y) => { hom := n • f.hom, comm := ⋯ } }

@[simp]

theorem Action.add_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (f g : X ⟶ Y) : (f + g).hom = f.hom + g.hom

@[simp]

theorem Action.neg_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (f : X ⟶ Y) : (-f).hom = -f.hom

@[simp]

theorem Action.sub_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (f g : X ⟶ Y) : (f - g).hom = f.hom - g.hom

@[simp]

theorem Action.nsmul_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (n : ℕ) (f : X ⟶ Y) : (n • f).hom = n • f.hom

@[simp]

theorem Action.zsmul_hom {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {X Y : Action V G} (n : ℤ) (f : X ⟶ Y) : (n • f).hom = n • f.hom

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

Equations

• Action.instPreadditive = { homGroup := fun (X Y : Action V G) => Function.Injective.addCommGroup Action.Hom.hom ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯, add_comp := ⋯, comp_add := ⋯ }

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

instance Action.forget₂_additive {V : Type u_1} [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] [CategoryTheory.HasForget V] : (CategoryTheory.forget₂ (Action V G) V).Additive

instance Action.functorCategoryEquivalence_additive {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] : (functorCategoryEquivalence V G).functor.Additive

@[simp]

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

instance Action.instLinear {V : Type u_1} [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Linear R (Action V G)

Equations

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

instance Action.forget_linear {V : Type u_1} [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Functor.Linear R (forget V G)

instance Action.forget₂_linear {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [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.Category.{u_4, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [Semiring R] [CategoryTheory.Linear R V] : CategoryTheory.Functor.Linear R (functorCategoryEquivalence V G).functor

@[simp]

theorem Action.smul_hom {V : Type u_1} [CategoryTheory.Category.{u_4, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [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.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {H : Type u_4} [Monoid H] (f : G →* H) : (res V f).Additive

instance Action.res_linear {V : Type u_1} [CategoryTheory.Category.{u_5, u_1} V] {G : Type u_2} [Monoid G] [CategoryTheory.Preadditive V] {R : Type u_3} [Semiring R] [CategoryTheory.Linear R V] {H : Type u_4} [Monoid H] (f : G →* H) : CategoryTheory.Functor.Linear R (res V f)

def Action.abelianAux {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

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

Equations

• Action.abelianAux = Action.functorCategoryEquivalence V G

noncomputable instance Action.instAbelian {V : Type u_1} [CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [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} [Category.{u_5, u_1} V] {W : Type u_3} [Category.{u_6, u_3} W] (F : Functor V W) (G : Type u_4) [Monoid G] [Preadditive V] [Preadditive W] [F.Additive] : (F.mapAction G).Additive

instance CategoryTheory.Functor.mapAction_linear {V : Type u_1} [Category.{u_6, u_1} V] {W : Type u_3} [Category.{u_7, u_3} W] (F : Functor V W) (G : Type u_4) [Monoid G] [Preadditive V] [Preadditive W] {R : Type u_5} [Semiring R] [CategoryTheory.Linear R V] [CategoryTheory.Linear R W] [Linear R F] : Linear R (F.mapAction G)