File: Mathlib/CategoryTheory/GradedObject/Single.lean

full_name: CategoryTheory.GradedObject.single
code: /-- The functor which sends `X : C` to the graded object which is `X` in degree `j`
and the initial object in other degrees. -/
noncomputable def single (j : J) : C ⥤ GradedObject J C 
goal: CategoryTheory.Functor C (CategoryTheory.GradedObject J C)

full_name: CategoryTheory.GradedObject.single₀
code: /-- The functor which sends `X : C` to the graded object which is `X` in degree `0`
and the initial object in nonzero degrees. -/
noncomputable abbrev single₀ [Zero J] : C ⥤ GradedObject J C 
goal: CategoryTheory.Functor C (CategoryTheory.GradedObject J C)

full_name: CategoryTheory.GradedObject.singleObjApplyIsoOfEq
code: /-- The canonical isomorphism `(single j).obj X i ≅ X` when `i = j`. -/
noncomputable def singleObjApplyIsoOfEq (j : J) (X : C) (i : J) (h : i = j) :
    (single j).obj X i ≅ X 
goal: (CategoryTheory.GradedObject.single j).obj X i ≅ X

full_name: CategoryTheory.GradedObject.singleObjApplyIso
code: /-- The canonical isomorphism `(single j).obj X j ≅ X`. -/
noncomputable abbrev singleObjApplyIso (j : J) (X : C) :
    (single j).obj X j ≅ X 
goal: (CategoryTheory.GradedObject.single j).obj X j ≅ X

full_name: CategoryTheory.GradedObject.isInitialSingleObjApply
code: /-- The object `(single j).obj X i` is initial when `i ≠ j`. -/
noncomputable def isInitialSingleObjApply (j : J) (X : C) (i : J) (h : i ≠ j) :
    IsInitial ((single j).obj X i) 
goal: CategoryTheory.Limits.IsInitial ((CategoryTheory.GradedObject.single j).obj X i)

full_name: CategoryTheory.GradedObject.singleObjApplyIsoOfEq_inv_single_map
code: lemma singleObjApplyIsoOfEq_inv_single_map (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j) :
    (singleObjApplyIsoOfEq j X i h).inv ≫ (single j).map f i =
      f ≫ (singleObjApplyIsoOfEq j Y i h).inv 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j X i h).inv
    ((CategoryTheory.GradedObject.single j).map f i) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j Y i h).inv

full_name: CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom
code: lemma single_map_singleObjApplyIsoOfEq_hom (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j) :
    (single j).map f i ≫ (singleObjApplyIsoOfEq j Y i h).hom =
      (singleObjApplyIsoOfEq j X i h).hom ≫ f 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f i)
    (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j Y i h).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j X i h).hom f

full_name: CategoryTheory.GradedObject.singleObjApplyIso_inv_single_map
code: @[reassoc (attr := simp)]
lemma singleObjApplyIso_inv_single_map (j : J) {X Y : C} (f : X ⟶ Y) :
    (singleObjApplyIso j X).inv ≫ (single j).map f j = f ≫ (singleObjApplyIso j Y).inv 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIso j X).inv
    ((CategoryTheory.GradedObject.single j).map f j) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.GradedObject.singleObjApplyIso j Y).inv

full_name: CategoryTheory.GradedObject.single_map_singleObjApplyIso_hom
code: @[reassoc (attr := simp)]
lemma single_map_singleObjApplyIso_hom (j : J) {X Y : C} (f : X ⟶ Y) :
    (single j).map f j ≫ (singleObjApplyIso j Y).hom = (singleObjApplyIso j X).hom ≫ f 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f j)
    (CategoryTheory.GradedObject.singleObjApplyIso j Y).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIso j X).hom f

full_name: CategoryTheory.GradedObject.singleCompEval_inv_app
code: /-- The composition of the single functor `single j : C ⥤ GradedObject J C` and the
evaluation functor `eval j` identifies to the identity functor. -/
@[simps!]
noncomputable def singleCompEval (j : J) : single j ⋙ eval j ≅ 𝟭 C 
goal: (CategoryTheory.GradedObject.singleCompEval C j).inv.app X = (CategoryTheory.GradedObject.singleObjApplyIso j X).inv

full_name: CategoryTheory.GradedObject.singleCompEval_hom_app
code: /-- The composition of the single functor `single j : C ⥤ GradedObject J C` and the
evaluation functor `eval j` identifies to the identity functor. -/
@[simps!]
noncomputable def singleCompEval (j : J) : single j ⋙ eval j ≅ 𝟭 C 
goal: (CategoryTheory.GradedObject.singleCompEval C j).hom.app X = (CategoryTheory.GradedObject.singleObjApplyIso j X).hom

full_name: CategoryTheory.GradedObject.singleCompEval
code: /-- The composition of the single functor `single j : C ⥤ GradedObject J C` and the
evaluation functor `eval j` identifies to the identity functor. -/
@[simps!]
noncomputable def singleCompEval (j : J) : single j ⋙ eval j ≅ 𝟭 C 
goal: (CategoryTheory.GradedObject.single j).comp (CategoryTheory.GradedObject.eval j) ≅ CategoryTheory.Functor.id C