File: Mathlib/CategoryTheory/Localization/FiniteProducts.lean

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.inverts
code: lemma inverts :
    (W.functorCategory (Discrete J)).IsInvertedBy (lim ⋙ L) 
goal: (W.functorCategory (CategoryTheory.Discrete J)).IsInvertedBy (CategoryTheory.Limits.lim.comp L)

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.limitFunctor
code: /-- The (candidate) limit functor for the localized category.
It is induced by `lim ⋙ L : (Discrete J ⥤ C) ⥤ D`. -/
noncomputable abbrev limitFunctor :
    (Discrete J ⥤ D) ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.Functor (CategoryTheory.Discrete J) D) D

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.compLimitFunctorIso
code: /-- The functor `limitFunctor L hW` is induced by `lim ⋙ L`. -/
noncomputable def compLimitFunctorIso :
    ((whiskeringRight (Discrete J) C D).obj L) ⋙ limitFunctor L hW ≅
      lim ⋙ L 
goal: ((CategoryTheory.whiskeringRight (CategoryTheory.Discrete J) C D).obj L).comp
    (CategoryTheory.Localization.HasProductsOfShapeAux.limitFunctor L hW) ≅
  CategoryTheory.Limits.lim.comp L

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.instCatCommSqFunctorDiscreteConstObjWhiskeringRight
code: instance :
    CatCommSq (Functor.const (Discrete J)) L
      ((whiskeringRight (Discrete J) C D).obj L) (Functor.const (Discrete J)) 
goal: CategoryTheory.CatCommSq (CategoryTheory.Functor.const (CategoryTheory.Discrete J)) L
  ((CategoryTheory.whiskeringRight (CategoryTheory.Discrete J) C D).obj L)
  (CategoryTheory.Functor.const (CategoryTheory.Discrete J))

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.instCatCommSqFunctorDiscreteLimObjWhiskeringRightLimitFunctor
code: noncomputable instance :
    CatCommSq lim ((whiskeringRight (Discrete J) C D).obj L) L (limitFunctor L hW) 
goal: CategoryTheory.CatCommSq CategoryTheory.Limits.lim
  ((CategoryTheory.whiskeringRight (CategoryTheory.Discrete J) C D).obj L) L
  (CategoryTheory.Localization.HasProductsOfShapeAux.limitFunctor L hW)

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.adj
code: /-- The adjunction between the constant functor `D ⥤ (Discrete J ⥤ D)`
and `limitFunctor L hW`. -/
noncomputable def adj :
    Functor.const _ ⊣ limitFunctor L hW 
goal: CategoryTheory.Functor.const (CategoryTheory.Discrete J) ⊣
  CategoryTheory.Localization.HasProductsOfShapeAux.limitFunctor L hW

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.adj_counit_app
code: lemma adj_counit_app (F : Discrete J ⥤ C) :
    (adj L hW).counit.app (F ⋙ L) =
      (Functor.const (Discrete J)).map ((compLimitFunctorIso L hW).hom.app F) ≫
        (Functor.compConstIso (Discrete J) L).hom.app (lim.obj F) ≫
        whiskerRight (constLimAdj.counit.app F) L 
goal: (CategoryTheory.Localization.HasProductsOfShapeAux.adj L hW).counit.app (F.comp L) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Functor.const (CategoryTheory.Discrete J)).map
      ((CategoryTheory.Localization.HasProductsOfShapeAux.compLimitFunctorIso L hW).hom.app F))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Functor.compConstIso (CategoryTheory.Discrete J) L).hom.app (CategoryTheory.Limits.lim.obj F))
      (CategoryTheory.whiskerRight (CategoryTheory.Limits.constLimAdj.counit.app F) L))

full_name: CategoryTheory.Localization.HasProductsOfShapeAux.isLimitMapCone
code: /-- Auxiliary definition for `Localization.preservesProductsOfShape`. -/
noncomputable def isLimitMapCone (F : Discrete J ⥤ C) :
    IsLimit (L.mapCone (limit.cone F)) 
goal: CategoryTheory.Limits.IsLimit (L.mapCone (CategoryTheory.Limits.limit.cone F))

full_name: CategoryTheory.Localization.hasProductsOfShape
code: lemma hasProductsOfShape (J : Type) [Finite J] [HasProductsOfShape J C]
    (hW : W.IsStableUnderProductsOfShape J) :
    HasProductsOfShape J D 
goal: CategoryTheory.Limits.HasProductsOfShape J D

full_name: CategoryTheory.Localization.preservesProductsOfShape
code: /-- When `C` has finite products indexed by `J`, `W : MorphismProperty C` contains
identities and is stable by products indexed by `J`,
then any localization functor for `W` preserves finite products indexed by `J`. -/
noncomputable def preservesProductsOfShape (J : Type) [Finite J]
    [HasProductsOfShape J C] (hW : W.IsStableUnderProductsOfShape J) :
    PreservesLimitsOfShape (Discrete J) L 
goal: CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete J) L

full_name: CategoryTheory.Localization.hasFiniteProducts
code: lemma hasFiniteProducts : HasFiniteProducts D 
goal: CategoryTheory.Limits.HasFiniteProducts D

full_name: CategoryTheory.Localization.preservesFiniteProducts
code: /-- When `C` has finite products and `W : MorphismProperty C` contains
identities and is stable by finite products,
then any localization functor for `W` preserves finite products. -/
noncomputable def preservesFiniteProducts :
    PreservesFiniteProducts L 
goal: CategoryTheory.Limits.PreservesFiniteProducts L

full_name: CategoryTheory.Localization.instHasFiniteProductsLocalization
code: instance : HasFiniteProducts (W.Localization) 
goal: CategoryTheory.Limits.HasFiniteProducts W.Localization

full_name: CategoryTheory.Localization.instPreservesFiniteProductsLocalizationQ
code: noncomputable instance : PreservesFiniteProducts W.Q 
goal: CategoryTheory.Limits.PreservesFiniteProducts W.Q

full_name: CategoryTheory.Localization.instHasFiniteProductsLocalization'
code: instance [W.HasLocalization] :
    HasFiniteProducts (W.Localization') 
goal: CategoryTheory.Limits.HasFiniteProducts W.Localization'

full_name: CategoryTheory.Localization.instPreservesFiniteProductsLocalization'Q'
code: noncomputable instance [W.HasLocalization] :
    PreservesFiniteProducts W.Q' 
goal: CategoryTheory.Limits.PreservesFiniteProducts W.Q'