File: Mathlib/RepresentationTheory/Action/Limits.lean

full_name: Action.instHasFiniteProducts
code: instance [HasFiniteProducts V] : HasFiniteProducts (Action V G) 
goal: CategoryTheory.Limits.HasFiniteProducts (Action V G)

full_name: Action.instHasFiniteLimits
code: instance [HasFiniteLimits V] : HasFiniteLimits (Action V G) 
goal: CategoryTheory.Limits.HasFiniteLimits (Action V G)

full_name: Action.instHasLimits
code: instance [HasLimits V] : HasLimits (Action V G) 
goal: CategoryTheory.Limits.HasLimits (Action V G)

full_name: Action.hasLimitsOfShape
code: /-- If `V` has limits of shape `J`, so does `Action V G`. -/
instance hasLimitsOfShape {J : Type w₁} [Category.{w₂} J] [HasLimitsOfShape J V] :
    HasLimitsOfShape J (Action V G) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (Action V G)

full_name: Action.instHasFiniteCoproducts
code: instance [HasFiniteCoproducts V] : HasFiniteCoproducts (Action V G) 
goal: CategoryTheory.Limits.HasFiniteCoproducts (Action V G)

full_name: Action.instHasFiniteColimits
code: instance [HasFiniteColimits V] : HasFiniteColimits (Action V G) 
goal: CategoryTheory.Limits.HasFiniteColimits (Action V G)

full_name: Action.instHasColimits
code: instance [HasColimits V] : HasColimits (Action V G) 
goal: CategoryTheory.Limits.HasColimits (Action V G)

full_name: Action.hasColimitsOfShape
code: /-- If `V` has colimits of shape `J`, so does `Action V G`. -/
instance hasColimitsOfShape {J : Type w₁} [Category.{w₂} J]
    [HasColimitsOfShape J V] : HasColimitsOfShape J (Action V G) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (Action V G)

full_name: _private.Mathlib.RepresentationTheory.Action.Limits.0.Action.SingleObj.preservesLimit
code: /-- `F : C ⥤ SingleObj G ⥤ V` preserves the limit of some `K : J ⥤ C` if it does
evaluated at `SingleObj.star G`. -/
private def SingleObj.preservesLimit (F : C ⥤ SingleObj G ⥤ V)
    {J : Type w₁} [Category.{w₂} J] (K : J ⥤ C)
    (h : PreservesLimit K (F ⋙ (evaluation (SingleObj G) V).obj (SingleObj.star G))) :
    PreservesLimit K F 
goal: CategoryTheory.Limits.PreservesLimit K F

full_name: Action.preservesLimitOfPreserves
code: /-- `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`. -/
noncomputable def preservesLimitOfPreserves (F : C ⥤ Action V G) {J : Type w₁}
    [Category.{w₂} J] (K : J ⥤ C)
    (h : PreservesLimit K (F ⋙ Action.forget V G)) : PreservesLimit K F 
goal: CategoryTheory.Limits.PreservesLimit K F

full_name: Action.preservesLimitsOfShapeOfPreserves
code: /-- `F : C ⥤ Action V G` preserves limits of some shape `J`
if it does after postcomposing with the forgetful functor `Action V G ⥤ V`. -/
noncomputable def preservesLimitsOfShapeOfPreserves (F : C ⥤ Action V G) {J : Type w₁}
    [Category.{w₂} J] (h : PreservesLimitsOfShape J (F ⋙ Action.forget V G)) :
    PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: Action.preservesLimitsOfSizeOfPreserves
code: /-- `F : C ⥤ Action V G` preserves limits of some size
if it does after postcomposing with the forgetful functor `Action V G ⥤ V`. -/
noncomputable def preservesLimitsOfSizeOfPreserves (F : C ⥤ Action V G)
    (h : PreservesLimitsOfSize.{w₂, w₁} (F ⋙ Action.forget V G)) :
    PreservesLimitsOfSize.{w₂, w₁} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} F

full_name: _private.Mathlib.RepresentationTheory.Action.Limits.0.Action.SingleObj.preservesColimit
code: /-- `F : C ⥤ SingleObj G ⥤ V` preserves the colimit of some `K : J ⥤ C` if it does
evaluated at `SingleObj.star G`. -/
private def SingleObj.preservesColimit (F : C ⥤ SingleObj G ⥤ V)
    {J : Type w₁} [Category.{w₂} J] (K : J ⥤ C)
    (h : PreservesColimit K (F ⋙ (evaluation (SingleObj G) V).obj (SingleObj.star G))) :
    PreservesColimit K F 
goal: CategoryTheory.Limits.PreservesColimit K F

full_name: Action.preservesColimitOfPreserves
code: /-- `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`. -/
noncomputable def preservesColimitOfPreserves (F : C ⥤ Action V G) {J : Type w₁}
    [Category.{w₂} J] (K : J ⥤ C)
    (h : PreservesColimit K (F ⋙ Action.forget V G)) : PreservesColimit K F 
goal: CategoryTheory.Limits.PreservesColimit K F

full_name: Action.preservesColimitsOfShapeOfPreserves
code: /-- `F : C ⥤ Action V G` preserves colimits of some shape `J`
if it does after postcomposing with the forgetful functor `Action V G ⥤ V`. -/
noncomputable def preservesColimitsOfShapeOfPreserves (F : C ⥤ Action V G) {J : Type w₁}
    [Category.{w₂} J] (h : PreservesColimitsOfShape J (F ⋙ Action.forget V G)) :
    PreservesColimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: Action.preservesColimitsOfSizeOfPreserves
code: /-- `F : C ⥤ Action V G` preserves colimits of some size
if it does after postcomposing with the forgetful functor `Action V G ⥤ V`. -/
noncomputable def preservesColimitsOfSizeOfPreserves (F : C ⥤ Action V G)
    (h : PreservesColimitsOfSize.{w₂, w₁} (F ⋙ Action.forget V G)) :
    PreservesColimitsOfSize.{w₂, w₁} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w₂, w₁, t₂, u, t₁, u + 1} F

full_name: Action.instPreservesLimitsOfShapeForgetOfHasLimitsOfShape
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] [HasLimitsOfShape J V] :
    PreservesLimitsOfShape J (Action.forget V G) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (Action.forget V G)

full_name: Action.instPreservesColimitsOfShapeForgetOfHasColimitsOfShape
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] [HasColimitsOfShape J V] :
    PreservesColimitsOfShape J (Action.forget V G) 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J (Action.forget V G)

full_name: Action.instPreservesFiniteLimitsForgetOfHasFiniteLimits
code: noncomputable instance [HasFiniteLimits V] : PreservesFiniteLimits (Action.forget V G) 
goal: CategoryTheory.Limits.PreservesFiniteLimits (Action.forget V G)

full_name: Action.instPreservesFiniteColimitsForgetOfHasFiniteColimits
code: noncomputable instance [HasFiniteColimits V] : PreservesFiniteColimits (Action.forget V G) 
goal: CategoryTheory.Limits.PreservesFiniteColimits (Action.forget V G)

full_name: Action.instReflectsLimitForget
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] (F : J ⥤ Action V G) :
    ReflectsLimit F (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsLimit F (Action.forget V G)

full_name: Action.instReflectsLimitsOfShapeForget
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] :
    ReflectsLimitsOfShape J (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J (Action.forget V G)

full_name: Action.instReflectsLimitsForget
code: noncomputable instance : ReflectsLimits (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsLimits (Action.forget V G)

full_name: Action.instReflectsColimitForget
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] (F : J ⥤ Action V G) :
    ReflectsColimit F (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsColimit F (Action.forget V G)

full_name: Action.instReflectsColimitsOfShapeForget
code: noncomputable instance {J : Type w₁} [Category.{w₂} J] :
    ReflectsColimitsOfShape J (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J (Action.forget V G)

full_name: Action.instReflectsColimitsForget
code: noncomputable instance : ReflectsColimits (Action.forget V G) 
goal: CategoryTheory.Limits.ReflectsColimits (Action.forget V G)

full_name: Action.instZeroHom
code: instance {X Y : Action V G} : Zero (X ⟶ Y) 
goal: Zero (X ⟶ Y)

full_name: Action.zero_hom
code: @[simp]
theorem zero_hom {X Y : Action V G} : (0 : X ⟶ Y).hom = 0 
goal: Action.Hom.hom 0 = 0

full_name: Action.instHasZeroMorphisms
code: instance : HasZeroMorphisms (Action V G) 
goal: CategoryTheory.Limits.HasZeroMorphisms (Action V G)

full_name: Action.forget_preservesZeroMorphisms
code: instance forget_preservesZeroMorphisms : Functor.PreservesZeroMorphisms (forget V G) 
goal: (Action.forget V G).PreservesZeroMorphisms

full_name: Action.forget₂_preservesZeroMorphisms
code: instance forget₂_preservesZeroMorphisms [ConcreteCategory V] :
    Functor.PreservesZeroMorphisms (forget₂ (Action V G) V) 
goal: (CategoryTheory.forget₂ (Action V G) V).PreservesZeroMorphisms

full_name: Action.functorCategoryEquivalence_preservesZeroMorphisms
code: instance functorCategoryEquivalence_preservesZeroMorphisms :
    Functor.PreservesZeroMorphisms (functorCategoryEquivalence V G).functor 
goal: (Action.functorCategoryEquivalence V G).functor.PreservesZeroMorphisms

full_name: Action.instAddHom
code: instance {X Y : Action V G} : Add (X ⟶ Y) 
goal: Add (X ⟶ Y)

full_name: Action.instNegHom
code: instance {X Y : Action V G} : Neg (X ⟶ Y) 
goal: Neg (X ⟶ Y)

full_name: Action.instPreadditive
code: instance : Preadditive (Action V G) 
goal: CategoryTheory.Preadditive (Action V G)

full_name: Action.forget_additive
code: instance forget_additive : Functor.Additive (forget V G) 
goal: (Action.forget V G).Additive

full_name: Action.forget₂_additive
code: instance forget₂_additive [ConcreteCategory V] : Functor.Additive (forget₂ (Action V G) V) 
goal: (CategoryTheory.forget₂ (Action V G) V).Additive

full_name: Action.functorCategoryEquivalence_additive
code: instance functorCategoryEquivalence_additive :
    Functor.Additive (functorCategoryEquivalence V G).functor 
goal: (Action.functorCategoryEquivalence V G).functor.Additive

full_name: Action.neg_hom
code: @[simp]
theorem neg_hom {X Y : Action V G} (f : X ⟶ Y) : (-f).hom = -f.hom 
goal: (-f).hom = -f.hom

full_name: Action.add_hom
code: @[simp]
theorem add_hom {X Y : Action V G} (f g : X ⟶ Y) : (f + g).hom = f.hom + g.hom 
goal: (f + g).hom = f.hom + g.hom

full_name: Action.sum_hom
code: @[simp]
theorem sum_hom {X Y : Action V G} {ι : Type*} (f : ι → (X ⟶ Y)) (s : Finset ι) :
    (s.sum f).hom = s.sum fun i => (f i).hom 
goal: (s.sum f).hom = ∑ i ∈ s, (f i).hom

full_name: Action.instLinear
code: instance : Linear R (Action V G) 
goal: CategoryTheory.Linear R (Action V G)

full_name: Action.forget_linear
code: instance forget_linear : Functor.Linear R (forget V G) 
goal: CategoryTheory.Functor.Linear R (Action.forget V G)

full_name: Action.forget₂_linear
code: instance forget₂_linear [ConcreteCategory V] : Functor.Linear R (forget₂ (Action V G) V) 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.forget₂ (Action V G) V)

full_name: Action.functorCategoryEquivalence_linear
code: instance functorCategoryEquivalence_linear :
    Functor.Linear R (functorCategoryEquivalence V G).functor 
goal: CategoryTheory.Functor.Linear R (Action.functorCategoryEquivalence V G).functor

full_name: Action.smul_hom
code: @[simp]
theorem smul_hom {X Y : Action V G} (r : R) (f : X ⟶ Y) : (r • f).hom = r • f.hom 
goal: (r • f).hom = r • f.hom

full_name: Action.res_additive
code: instance res_additive : (res V f).Additive 
goal: (Action.res V f).Additive

full_name: Action.res_linear
code: instance res_linear : (res V f).Linear R 
goal: CategoryTheory.Functor.Linear R (Action.res V f)

full_name: Action.abelianAux
code: /-- Auxiliary construction for the `Abelian (Action V G)` instance. -/
def abelianAux : Action V G ≌ ULift.{u} (SingleObj G) ⥤ V 
goal: Action V G ≌ ULift.{u, 0} (CategoryTheory.SingleObj ↑G) ⥤ V

full_name: Action.instAbelian
code: noncomputable instance [Abelian V] : Abelian (Action V G) 
goal: CategoryTheory.Abelian (Action V G)

full_name: CategoryTheory.Functor.mapAction_preadditive
code: instance mapAction_preadditive [F.Additive] : (F.mapAction G).Additive 
goal: (F.mapAction G).Additive

full_name: CategoryTheory.Functor.mapAction_linear
code: instance mapAction_linear [F.Additive] [F.Linear R] : (F.mapAction G).Linear R 
goal: CategoryTheory.Functor.Linear R (F.mapAction G)