File: Mathlib/CategoryTheory/GradedObject.lean

full_name: CategoryTheory.GradedObject
code: /-- A type synonym for `β → C`, used for `β`-graded objects in a category `C`. -/
def GradedObject (β : Type w) (C : Type u) : Type max w u 
goal: Type (max w u)

full_name: CategoryTheory.inhabitedGradedObject
code: instance inhabitedGradedObject (β : Type w) (C : Type u) [Inhabited C] :
    Inhabited (GradedObject β C) 
goal: Inhabited (CategoryTheory.GradedObject β C)

full_name: CategoryTheory.GradedObjectWithShift
code: /-- A type synonym for `β → C`, used for `β`-graded objects in a category `C`
with a shift functor given by translation by `s`.
-/
@[nolint unusedArguments]
abbrev GradedObjectWithShift {β : Type w} [AddCommGroup β] (_ : β) (C : Type u) : Type max w u 
goal: β → Type u → Type (max w u)

full_name: CategoryTheory.GradedObject.categoryOfGradedObjects_comp
code: @[simps!]
instance categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) 
goal: ∀ {X Y Z : (i : β) → (fun x => C) i} (f : X ⟶ Y) (g : Y ⟶ Z) (i : β),
  CategoryTheory.CategoryStruct.comp f g i = CategoryTheory.CategoryStruct.comp (f i) (g i)

full_name: CategoryTheory.GradedObject.categoryOfGradedObjects
code: @[simps!]
instance categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) 
goal: CategoryTheory.Category.{max w v, max u w} (CategoryTheory.GradedObject β C)

full_name: CategoryTheory.GradedObject.categoryOfGradedObjects_id
code: @[simps!]
instance categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) 
goal: CategoryTheory.CategoryStruct.id X i = CategoryTheory.CategoryStruct.id (X i)

full_name: CategoryTheory.GradedObject.hom_ext
code: @[ext]
lemma hom_ext {β : Type*} {X Y : GradedObject β C} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: CategoryTheory.GradedObject.eval_obj
code: /-- The projection of a graded object to its `i`-th component. -/
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C 
goal: (CategoryTheory.GradedObject.eval b).obj X = X b

full_name: CategoryTheory.GradedObject.eval
code: /-- The projection of a graded object to its `i`-th component. -/
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.GradedObject β C) C

full_name: CategoryTheory.GradedObject.eval_map
code: /-- The projection of a graded object to its `i`-th component. -/
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C 
goal: ∀ {X Y : CategoryTheory.GradedObject β C} (f : X ⟶ Y), (CategoryTheory.GradedObject.eval b).map f = f b

full_name: CategoryTheory.GradedObject.isoMk
code: /-- Constructor for isomorphisms in `GradedObject` -/
@[simps]
def isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.GradedObject.isoMk_inv
code: /-- Constructor for isomorphisms in `GradedObject` -/
@[simps]
def isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y 
goal: (X.isoMk Y e).inv i = (e i).inv

full_name: CategoryTheory.GradedObject.isoMk_hom
code: /-- Constructor for isomorphisms in `GradedObject` -/
@[simps]
def isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y 
goal: (X.isoMk Y e).hom i = (e i).hom

full_name: CategoryTheory.GradedObject.isIso_of_isIso_apply
code: lemma isIso_of_isIso_apply (f : X ⟶ Y) [hf : ∀ i, IsIso (f i)] :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.GradedObject.isIso_apply_of_isIso
code: instance isIso_apply_of_isIso (f : X ⟶ Y) [IsIso f] (i : β) : IsIso (f i) 
goal: CategoryTheory.IsIso (f i)

full_name: CategoryTheory.Iso.hom_inv_id_eval
code: @[reassoc (attr := simp)]
lemma hom_inv_id_eval (e : X ≅ Y) (j : J) :
    e.hom j ≫ e.inv j = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (e.hom j) (e.inv j) = CategoryTheory.CategoryStruct.id (X j)

full_name: CategoryTheory.Iso.inv_hom_id_eval
code: @[reassoc (attr := simp)]
lemma inv_hom_id_eval (e : X ≅ Y) (j : J) :
    e.inv j ≫ e.hom j = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (e.inv j) (e.hom j) = CategoryTheory.CategoryStruct.id (Y j)

full_name: CategoryTheory.Iso.map_hom_inv_id_eval
code: @[reassoc (attr := simp)]
lemma map_hom_inv_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
    F.map (e.hom j) ≫ F.map (e.inv j) = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.map (e.hom j)) (F.map (e.inv j)) = CategoryTheory.CategoryStruct.id (F.obj (X j))

full_name: CategoryTheory.Iso.map_inv_hom_id_eval
code: @[reassoc (attr := simp)]
lemma map_inv_hom_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
    F.map (e.inv j) ≫ F.map (e.hom j) = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.map (e.inv j)) (F.map (e.hom j)) = CategoryTheory.CategoryStruct.id (F.obj (Y j))

full_name: CategoryTheory.Iso.map_hom_inv_id_eval_app
code: @[reassoc (attr := simp)]
lemma map_hom_inv_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.hom j)).app Y ≫ (F.map (e.inv j)).app Y = 𝟙 _ 
goal: ∀ (Y_1 : D),
  CategoryTheory.CategoryStruct.comp ((F.map (e.hom j)).app Y_1) ((F.map (e.inv j)).app Y_1) =
    CategoryTheory.CategoryStruct.id ((F.obj (X j)).obj Y_1)

full_name: CategoryTheory.Iso.map_inv_hom_id_eval_app
code: @[reassoc (attr := simp)]
lemma map_inv_hom_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.inv j)).app Y ≫ (F.map (e.hom j)).app Y = 𝟙 _ 
goal: ∀ (Y_1 : D),
  CategoryTheory.CategoryStruct.comp ((F.map (e.inv j)).app Y_1) ((F.map (e.hom j)).app Y_1) =
    CategoryTheory.CategoryStruct.id ((F.obj (Y j)).obj Y_1)

full_name: CategoryTheory.GradedObject.comap
code: /-- Pull back an `I`-graded object in `C` to a `J`-graded object along a function `J → I`. -/
abbrev comap {I J : Type*} (h : J → I) : GradedObject I C ⥤ GradedObject J C 
goal: CategoryTheory.Functor (CategoryTheory.GradedObject I C) (CategoryTheory.GradedObject J C)

full_name: CategoryTheory.GradedObject.eqToHom_proj
code: @[simp]
theorem eqToHom_proj {I : Type*} {x x' : GradedObject I C} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i) 
goal: CategoryTheory.eqToHom h i = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.GradedObject.comapEq_hom_app
code: /-- The natural isomorphism comparing between
pulling back along two propositionally equal functions.
-/
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g 
goal: (CategoryTheory.GradedObject.comapEq C h).hom.app X b = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.GradedObject.comapEq
code: /-- The natural isomorphism comparing between
pulling back along two propositionally equal functions.
-/
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g 
goal: CategoryTheory.GradedObject.comap C f ≅ CategoryTheory.GradedObject.comap C g

full_name: CategoryTheory.GradedObject.comapEq_inv_app
code: /-- The natural isomorphism comparing between
pulling back along two propositionally equal functions.
-/
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g 
goal: (CategoryTheory.GradedObject.comapEq C h).inv.app X b = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.GradedObject.comapEq_symm
code: theorem comapEq_symm {β γ : Type w} {f g : β → γ} (h : f = g) :
    comapEq C h.symm = (comapEq C h).symm 
goal: CategoryTheory.GradedObject.comapEq C ⋯ = (CategoryTheory.GradedObject.comapEq C h).symm

full_name: CategoryTheory.GradedObject.comapEq_trans
code: theorem comapEq_trans {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h) :
    comapEq C (k.trans l) = comapEq C k ≪≫ comapEq C l 
goal: CategoryTheory.GradedObject.comapEq C ⋯ =
  CategoryTheory.GradedObject.comapEq C k ≪≫ CategoryTheory.GradedObject.comapEq C l

full_name: CategoryTheory.GradedObject.eqToHom_apply
code: theorem eqToHom_apply {β : Type w} {X Y : β → C} (h : X = Y) (b : β) :
    (eqToHom h : X ⟶ Y) b = eqToHom (by rw [h]) 
goal: CategoryTheory.eqToHom h b = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.GradedObject.comapEquiv_inverse
code: /-- The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ.
-/
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
goal: (CategoryTheory.GradedObject.comapEquiv C e).inverse = CategoryTheory.GradedObject.comap C ⇑e

full_name: CategoryTheory.GradedObject.comapEquiv
code: /-- The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ.
-/
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
goal: CategoryTheory.GradedObject β C ≌ CategoryTheory.GradedObject γ C

full_name: CategoryTheory.GradedObject.comapEquiv_functor
code: /-- The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ.
-/
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
goal: (CategoryTheory.GradedObject.comapEquiv C e).functor = CategoryTheory.GradedObject.comap C ⇑e.symm

full_name: CategoryTheory.GradedObject.comapEquiv_unitIso
code: /-- The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ.
-/
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
goal: (CategoryTheory.GradedObject.comapEquiv C e).unitIso =
  CategoryTheory.GradedObject.comapEq C ⋯ ≪≫ (CategoryTheory.Pi.comapComp (fun x => C) ⇑e ⇑e.symm).symm

full_name: CategoryTheory.GradedObject.comapEquiv_counitIso
code: /-- The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ.
-/
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
goal: (CategoryTheory.GradedObject.comapEquiv C e).counitIso =
  CategoryTheory.Pi.comapComp (fun x => C) ⇑e.symm ⇑e ≪≫ CategoryTheory.GradedObject.comapEq C ⋯

full_name: CategoryTheory.GradedObject.hasShift
code: instance hasShift {β : Type*} [AddCommGroup β] (s : β) : HasShift (GradedObjectWithShift s C) ℤ 
goal: CategoryTheory.HasShift (CategoryTheory.GradedObjectWithShift s C) ℤ

full_name: CategoryTheory.GradedObject.shiftFunctor_obj_apply
code: @[simp]
theorem shiftFunctor_obj_apply {β : Type*} [AddCommGroup β] (s : β) (X : β → C) (t : β) (n : ℤ) :
    (shiftFunctor (GradedObjectWithShift s C) n).obj X t = X (t + n • s) 
goal: (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).obj X t = X (t + n • s)

full_name: CategoryTheory.GradedObject.shiftFunctor_map_apply
code: @[simp]
theorem shiftFunctor_map_apply {β : Type*} [AddCommGroup β] (s : β)
    {X Y : GradedObjectWithShift s C} (f : X ⟶ Y) (t : β) (n : ℤ) :
    (shiftFunctor (GradedObjectWithShift s C) n).map f t = f (t + n • s) 
goal: (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).map f t = f (t + n • s)

full_name: CategoryTheory.GradedObject.instZeroHomOfHasZeroMorphisms
code: instance [HasZeroMorphisms C] (β : Type w) (X Y : GradedObject β C) :
  Zero (X ⟶ Y) 
goal: Zero (X ⟶ Y)

full_name: CategoryTheory.GradedObject.zero_apply
code: @[simp, nolint simpNF]
theorem zero_apply [HasZeroMorphisms C] (β : Type w) (X Y : GradedObject β C) (b : β) :
    (0 : X ⟶ Y) b = 0 
goal: 0 b = 0

full_name: CategoryTheory.GradedObject.hasZeroMorphisms
code: instance hasZeroMorphisms [HasZeroMorphisms C] (β : Type w) :
    HasZeroMorphisms.{max w v} (GradedObject β C) 
goal: CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.GradedObject β C)

full_name: CategoryTheory.GradedObject.hasZeroObject
code: instance hasZeroObject [HasZeroObject C] [HasZeroMorphisms C] (β : Type w) :
    HasZeroObject.{max w v} (GradedObject β C) 
goal: CategoryTheory.Limits.HasZeroObject (CategoryTheory.GradedObject β C)

full_name: CategoryTheory.GradedObject.total
code: /-- The total object of a graded object is the coproduct of the graded components.
-/
noncomputable def total : GradedObject β C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.GradedObject β C) C

full_name: CategoryTheory.GradedObject.instFaithfulTotal
code: /--
The `total` functor taking a graded object to the coproduct of its graded components is faithful.
To prove this, we need to know that the coprojections into the coproduct are monomorphisms,
which follows from the fact we have zero morphisms and decidable equality for the grading.
-/
instance : (total β C).Faithful 
goal: (CategoryTheory.GradedObject.total β C).Faithful

full_name: CategoryTheory.GradedObject.instConcreteCategory
code: instance : ConcreteCategory (GradedObject β C) 
goal: CategoryTheory.ConcreteCategory (CategoryTheory.GradedObject β C)

full_name: CategoryTheory.GradedObject.instHasForget₂
code: instance : HasForget₂ (GradedObject β C) C 
goal: CategoryTheory.HasForget₂ (CategoryTheory.GradedObject β C) C

full_name: CategoryTheory.GradedObject.mapObjFun
code: /-- If `X : GradedObject I C` and `p : I → J`, `X.mapObjFun p j` is the family of objects `X i`
for `i : I` such that `p i = j`. -/
abbrev mapObjFun (j : J) (i : p ⁻¹' {j}) : C 
goal: C

full_name: CategoryTheory.GradedObject.HasMap
code: /-- Given `X : GradedObject I C` and `p : I → J`, `X.HasMap p` is the condition that
for all `j : J`, the coproduct of all `X i` such `p i = j` exists. -/
abbrev HasMap : Prop 
goal: Prop

full_name: CategoryTheory.GradedObject.hasMap_of_iso
code: lemma hasMap_of_iso (e : X ≅ Y) (p: I → J) [HasMap X p] : HasMap Y p 
goal: Y.HasMap p

full_name: CategoryTheory.GradedObject.mapObj
code: /-- Given `X : GradedObject I C` and `p : I → J`, `X.mapObj p` is the graded object by `J`
which in degree `j` consists of the coproduct of the `X i` such that `p i = j`. -/
noncomputable def mapObj : GradedObject J C 
goal: CategoryTheory.GradedObject J C

full_name: CategoryTheory.GradedObject.ιMapObj
code: /-- The canonical inclusion `X i ⟶ X.mapObj p j` when `i : I` and `j : J` are such
that `p i = j`. -/
noncomputable def ιMapObj (i : I) (j : J) (hij : p i = j) : X i ⟶ X.mapObj p j 
goal: X i ⟶ X.mapObj p j

full_name: CategoryTheory.GradedObject.CofanMapObjFun
code: /-- Given `X : GradedObject I C`, `p : I → J` and `j : J`,
`CofanMapObjFun X p j` is the type `Cofan (X.mapObjFun p j)`. The point object of
such colimits cofans are isomorphic to `X.mapObj p j`, see `CofanMapObjFun.iso`. -/
abbrev CofanMapObjFun (j : J) : Type _ 
goal: Type (max (max u_4 u_5) u_1)

full_name: CategoryTheory.GradedObject.CofanMapObjFun.mk
code: /-- Constructor for `CofanMapObjFun X p j`. -/
@[simp]
def CofanMapObjFun.mk (j : J) (pt : C) (ι' : ∀ (i : I) (_ : p i = j), X i ⟶ pt) :
    CofanMapObjFun X p j 
goal: X.CofanMapObjFun p j

full_name: CategoryTheory.GradedObject.cofanMapObj
code: /-- The tautological cofan corresponding to the coproduct decomposition of `X.mapObj p j`. -/
@[simp]
noncomputable def cofanMapObj (j : J) : CofanMapObjFun X p j 
goal: X.CofanMapObjFun p j

full_name: CategoryTheory.GradedObject.isColimitCofanMapObj
code: /-- Given `X : GradedObject I C`, `p : I → J` and `j : J`, `X.mapObj p j` satisfies
the universal property of the coproduct of those `X i` such that `p i = j`. -/
noncomputable def isColimitCofanMapObj (j : J) : IsColimit (X.cofanMapObj p j) 
goal: CategoryTheory.Limits.IsColimit (X.cofanMapObj p j)

full_name: CategoryTheory.GradedObject.mapObj_ext
code: @[ext]
lemma mapObj_ext {A : C} {j : J} (f g : X.mapObj p j ⟶ A)
    (hfg : ∀ (i : I) (hij : p i = j), X.ιMapObj p i j hij ≫ f = X.ιMapObj p i j hij ≫ g) :
    f = g 
goal: f = g

full_name: CategoryTheory.GradedObject.descMapObj
code: /-- This is the morphism `X.mapObj p j ⟶ A` constructed from a family of
morphisms `X i ⟶ A` for all `i : I` such that `p i = j`. -/
noncomputable def descMapObj {A : C} {j : J} (φ : ∀ (i : I) (_ : p i = j), X i ⟶ A) :
    X.mapObj p j ⟶ A 
goal: X.mapObj p j ⟶ A

full_name: CategoryTheory.GradedObject.ι_descMapObj
code: @[reassoc (attr := simp)]
lemma ι_descMapObj {A : C} {j : J}
    (φ : ∀ (i : I) (_ : p i = j), X i ⟶ A) (i : I) (hi : p i = j) :
    X.ιMapObj p i j hi ≫ X.descMapObj p φ = φ i hi 
goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hi) (X.descMapObj p φ) = φ i hi

full_name: CategoryTheory.GradedObject.CofanMapObjFun.hasMap
code: lemma hasMap (c : ∀ j, CofanMapObjFun X p j) (hc : ∀ j, IsColimit (c j)) :
    X.HasMap p 
goal: X.HasMap p

full_name: CategoryTheory.GradedObject.CofanMapObjFun.iso
code: /-- If `c : CofanMapObjFun X p j` is a colimit cofan, this is the induced
isomorphism `c.pt ≅ X.mapObj p j`. -/
noncomputable def iso : c.pt ≅ X.mapObj p j 
goal: c.pt ≅ X.mapObj p j

full_name: CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom
code: @[reassoc (attr := simp)]
lemma inj_iso_hom (i : I) (hi : p i = j) :
    c.inj ⟨i, hi⟩ ≫ (c.iso hc).hom = X.ιMapObj p i j hi 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c ⟨i, hi⟩)
    (CategoryTheory.GradedObject.CofanMapObjFun.iso hc).hom =
  X.ιMapObj p i j hi

full_name: CategoryTheory.GradedObject.CofanMapObjFun.ιMapObj_iso_inv
code: @[reassoc (attr := simp)]
lemma ιMapObj_iso_inv (i : I) (hi : p i = j) :
    X.ιMapObj p i j hi ≫ (c.iso hc).inv = c.inj ⟨i, hi⟩ 
goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hi) (CategoryTheory.GradedObject.CofanMapObjFun.iso hc).inv =
  CategoryTheory.Limits.Cofan.inj c ⟨i, hi⟩

full_name: CategoryTheory.GradedObject.mapMap
code: /-- The canonical morphism of `J`-graded objects `X.mapObj p ⟶ Y.mapObj p` induced by
a morphism `X ⟶ Y` of `I`-graded objects and a map `p : I → J`. -/
noncomputable def mapMap : X.mapObj p ⟶ Y.mapObj p 
goal: X.mapObj p ⟶ Y.mapObj p

full_name: CategoryTheory.GradedObject.ι_mapMap
code: @[reassoc (attr := simp)]
lemma ι_mapMap (i : I) (j : J) (hij : p i = j) :
    X.ιMapObj p i j hij ≫ mapMap φ p j = φ i ≫ Y.ιMapObj p i j hij 
goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hij) (CategoryTheory.GradedObject.mapMap φ p j) =
  CategoryTheory.CategoryStruct.comp (φ i) (Y.ιMapObj p i j hij)

full_name: CategoryTheory.GradedObject.congr_mapMap
code: lemma congr_mapMap (φ₁ φ₂ : X ⟶ Y) (h : φ₁ = φ₂) : mapMap φ₁ p = mapMap φ₂ p 
goal: CategoryTheory.GradedObject.mapMap φ₁ p = CategoryTheory.GradedObject.mapMap φ₂ p

full_name: CategoryTheory.GradedObject.mapMap_id
code: @[simp]
lemma mapMap_id : mapMap (𝟙 X) p = 𝟙 _ 
goal: CategoryTheory.GradedObject.mapMap (CategoryTheory.CategoryStruct.id X) p =
  CategoryTheory.CategoryStruct.id (X.mapObj p)

full_name: CategoryTheory.GradedObject.mapMap_comp
code: @[simp, reassoc]
lemma mapMap_comp : mapMap (φ ≫ ψ) p = mapMap φ p ≫ mapMap ψ p 
goal: CategoryTheory.GradedObject.mapMap (CategoryTheory.CategoryStruct.comp φ ψ) p =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapMap φ p) (CategoryTheory.GradedObject.mapMap ψ p)

full_name: CategoryTheory.GradedObject.mapIso_hom
code: /-- The isomorphism of `J`-graded objects `X.mapObj p ≅ Y.mapObj p` induced by an
isomorphism `X ≅ Y` of graded objects and a map `p : I → J`. -/
@[simps]
noncomputable def mapIso : X.mapObj p ≅ Y.mapObj p 
goal: (CategoryTheory.GradedObject.mapIso e p).hom i = CategoryTheory.GradedObject.mapMap e.hom p i

full_name: CategoryTheory.GradedObject.mapIso_inv
code: /-- The isomorphism of `J`-graded objects `X.mapObj p ≅ Y.mapObj p` induced by an
isomorphism `X ≅ Y` of graded objects and a map `p : I → J`. -/
@[simps]
noncomputable def mapIso : X.mapObj p ≅ Y.mapObj p 
goal: (CategoryTheory.GradedObject.mapIso e p).inv i = CategoryTheory.GradedObject.mapMap e.inv p i

full_name: CategoryTheory.GradedObject.mapIso
code: /-- The isomorphism of `J`-graded objects `X.mapObj p ≅ Y.mapObj p` induced by an
isomorphism `X ≅ Y` of graded objects and a map `p : I → J`. -/
@[simps]
noncomputable def mapIso : X.mapObj p ≅ Y.mapObj p 
goal: X.mapObj p ≅ Y.mapObj p

full_name: CategoryTheory.GradedObject.map_obj
code: /-- Given a map `p : I → J`, this is the functor `GradedObject I C ⥤ GradedObject J C` which
sends an `I`-object `X` to the graded object `X.mapObj p` which in degree `j : J` is given
by the coproduct of those `X i` such that `p i = j`. -/
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C 
goal: (CategoryTheory.GradedObject.map C p).obj X = X.mapObj p

full_name: CategoryTheory.GradedObject.map_map
code: /-- Given a map `p : I → J`, this is the functor `GradedObject I C ⥤ GradedObject J C` which
sends an `I`-object `X` to the graded object `X.mapObj p` which in degree `j : J` is given
by the coproduct of those `X i` such that `p i = j`. -/
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C 
goal: ∀ {X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (i : J),
  (CategoryTheory.GradedObject.map C p).map φ i = CategoryTheory.GradedObject.mapMap φ p i

full_name: CategoryTheory.GradedObject.map
code: /-- Given a map `p : I → J`, this is the functor `GradedObject I C ⥤ GradedObject J C` which
sends an `I`-object `X` to the graded object `X.mapObj p` which in degree `j : J` is given
by the coproduct of those `X i` such that `p i = j`. -/
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C 
goal: CategoryTheory.Functor (CategoryTheory.GradedObject I C) (CategoryTheory.GradedObject J C)

full_name: CategoryTheory.GradedObject.cofanMapObjComp
code: /-- Given maps `p : I → J`, `q : J → K` and `r : I → K` such that `q.comp p = r`,
`X : GradedObject I C`, `k : K`, the datum of cofans `X.CofanMapObjFun p j` for all
`j : J` and of a cofan for all the points of these cofans, this is a cofan of
type `X.CofanMapObjFun r k`, which is a colimit (see `isColimitCofanMapObjComp`) if the
given cofans are. -/
@[simp]
def cofanMapObjComp : X.CofanMapObjFun r k 
goal: X.CofanMapObjFun r k

full_name: CategoryTheory.GradedObject.isColimitCofanMapObjComp
code: /-- Given maps `p : I → J`, `q : J → K` and `r : I → K` such that `q.comp p = r`,
`X : GradedObject I C`, `k : K`, the cofan constructed by `cofanMapObjComp` is a colimit.
In other words, if we have, for all `j : J` such that `hj : q j = k`,
a colimit cofan `c j hj` which computes the coproduct of the `X i` such that `p i = j`,
and also a colimit cofan which computes the coproduct of the points of these `c j hj`, then
the point of this latter cofan computes the coproduct of the `X i` such that `r i = k`. -/
@[simp]
def isColimitCofanMapObjComp :
    IsColimit (cofanMapObjComp X p q r hpqr k c c') 
goal: CategoryTheory.Limits.IsColimit (X.cofanMapObjComp p q r hpqr k c c')

full_name: CategoryTheory.GradedObject.hasMap_comp
code: lemma hasMap_comp [X.HasMap p] [(X.mapObj p).HasMap q] : X.HasMap r 
goal: X.HasMap r

full_name: CategoryTheory.GradedObject.ιMapObjOrZero
code: /-- The canonical inclusion `X i ⟶ X.mapObj p j` when `p i = j`, the zero morphism otherwise. -/
noncomputable def ιMapObjOrZero : X i ⟶ X.mapObj p j 
goal: X i ⟶ X.mapObj p j

full_name: CategoryTheory.GradedObject.ιMapObjOrZero_eq
code: lemma ιMapObjOrZero_eq (h : p i = j) : X.ιMapObjOrZero p i j = X.ιMapObj p i j h 
goal: X.ιMapObjOrZero p i j = X.ιMapObj p i j h

full_name: CategoryTheory.GradedObject.ιMapObjOrZero_eq_zero
code: lemma ιMapObjOrZero_eq_zero (h : p i ≠ j) : X.ιMapObjOrZero p i j = 0 
goal: X.ιMapObjOrZero p i j = 0

full_name: CategoryTheory.GradedObject.ιMapObjOrZero_mapMap
code: @[reassoc (attr := simp)]
lemma ιMapObjOrZero_mapMap :
    X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j 
goal: CategoryTheory.CategoryStruct.comp (X.ιMapObjOrZero p i j) (CategoryTheory.GradedObject.mapMap φ p j) =
  CategoryTheory.CategoryStruct.comp (φ i) (Y.ιMapObjOrZero p i j)