Documentation

Mathlib.CategoryTheory.GradedObject

The category of graded objects #

For any type β, a β-graded object over some category C is just a function β → C into the objects of C. We put the "pointwise" category structure on these, as the non-dependent specialization of CategoryTheory.Pi.

We describe the comap functors obtained by precomposing with functions β → γ.

As a consequence a fixed element (e.g. 1) in an additive group β provides a shift functor on β-graded objects

When C has coproducts we construct the total functor GradedObject β C ⥤ C, show that it is faithful, and deduce that when C is concrete so is GradedObject β C.

def CategoryTheory.GradedObject (β : Type w) (C : Type u) :
Type (max w u)

A type synonym for β → C, used for β-graded objects in a category C.

Instances For
    @[inline, reducible]
    abbrev CategoryTheory.GradedObjectWithShift {β : Type w} [AddCommGroup β] :
    βType u → Type (max w u)

    A type synonym for β → C, used for β-graded objects in a category C with a shift functor given by translation by s.

    Instances For
      @[simp]
      theorem CategoryTheory.GradedObject.categoryOfGradedObjects_id {C : Type u} [CategoryTheory.Category.{v, u} C] (β : Type w) (X : (i : β) → (fun x => C) i) (i : β) :
      @[simp]
      theorem CategoryTheory.GradedObject.categoryOfGradedObjects_comp {C : Type u} [CategoryTheory.Category.{v, u} C] (β : Type w) :
      ∀ {X Y Z : (i : β) → (fun x => C) i} (f : X Y) (g : Y Z) (i : β), CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject β C) CategoryTheory.Category.toCategoryStruct X Y Z f g i = CategoryTheory.CategoryStruct.comp (f i) (g i)
      theorem CategoryTheory.GradedObject.hom_ext {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} {X : CategoryTheory.GradedObject β C} {Y : CategoryTheory.GradedObject β C} (f : X Y) (g : X Y) (h : ∀ (x : β), f x = g x) :
      f = g
      @[simp]

      The projection of a graded object to its i-th component.

      Instances For
        @[inline, reducible]

        Pull back an I-graded object in C to a J-graded object along a function J → I.

        Instances For
          @[simp]
          theorem CategoryTheory.GradedObject.comapEq_inv_app (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} {f : βγ} {g : βγ} (h : f = g) (X : CategoryTheory.GradedObject γ C) (b : β) :
          (CategoryTheory.GradedObject γ C).app (CategoryTheory.GradedObject.categoryOfGradedObjects γ) (CategoryTheory.GradedObject β C) (CategoryTheory.GradedObject.categoryOfGradedObjects β) (CategoryTheory.GradedObject.comap C g) (CategoryTheory.GradedObject.comap C f) (CategoryTheory.GradedObject.comapEq C h).inv X b = CategoryTheory.eqToHom (_ : (CategoryTheory.GradedObject γ C).obj CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject β C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject.comap C g).toPrefunctor X b = (CategoryTheory.GradedObject γ C).obj CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject β C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject.comap C f).toPrefunctor X b)
          @[simp]
          theorem CategoryTheory.GradedObject.comapEq_hom_app (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} {f : βγ} {g : βγ} (h : f = g) (X : CategoryTheory.GradedObject γ C) (b : β) :
          (CategoryTheory.GradedObject γ C).app (CategoryTheory.GradedObject.categoryOfGradedObjects γ) (CategoryTheory.GradedObject β C) (CategoryTheory.GradedObject.categoryOfGradedObjects β) (CategoryTheory.GradedObject.comap C f) (CategoryTheory.GradedObject.comap C g) (CategoryTheory.GradedObject.comapEq C h).hom X b = CategoryTheory.eqToHom (_ : (CategoryTheory.GradedObject γ C).obj CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject β C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject.comap C f).toPrefunctor X b = (CategoryTheory.GradedObject γ C).obj CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject β C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObject.comap C g).toPrefunctor X b)

          The natural isomorphism comparing between pulling back along two propositionally equal functions.

          Instances For
            theorem CategoryTheory.GradedObject.comapEq_symm (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} {f : βγ} {g : βγ} (h : f = g) :
            theorem CategoryTheory.GradedObject.comapEq_trans (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} {f : βγ} {g : βγ} {h : βγ} (k : f = g) (l : g = h) :
            @[simp]
            theorem CategoryTheory.GradedObject.eqToHom_apply (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {X : βC} {Y : βC} (h : X = Y) (b : β) :
            CategoryTheory.eqToHom (βC) (CategoryTheory.pi fun x => C) X Y h b = CategoryTheory.eqToHom (_ : X b = Y b)
            @[simp]
            theorem CategoryTheory.GradedObject.comapEquiv_unitIso (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} (e : β γ) :
            (CategoryTheory.GradedObject.comapEquiv C e).unitIso = CategoryTheory.GradedObject.comapEq C (_ : (fun i => i) = e.symm e) ≪≫ (CategoryTheory.Pi.comapComp (fun x => C) e e.symm).symm
            @[simp]
            theorem CategoryTheory.GradedObject.comapEquiv_counitIso (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {γ : Type w} (e : β γ) :
            (CategoryTheory.GradedObject.comapEquiv C e).counitIso = CategoryTheory.Pi.comapComp (fun x => C) e.symm e ≪≫ CategoryTheory.GradedObject.comapEq C (_ : e e.symm = fun i => i)

            The equivalence between β-graded objects and γ-graded objects, given an equivalence between β and γ.

            Instances For
              @[simp]
              theorem CategoryTheory.GradedObject.shiftFunctor_obj_apply {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} [AddCommGroup β] (s : β) (X : βC) (t : β) (n : ) :
              (CategoryTheory.GradedObjectWithShift s C).obj CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObjectWithShift s C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).toPrefunctor X t = X (t + n s)
              @[simp]
              theorem CategoryTheory.GradedObject.shiftFunctor_map_apply {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} [AddCommGroup β] (s : β) {X : CategoryTheory.GradedObjectWithShift s C} {Y : CategoryTheory.GradedObjectWithShift s C} (f : X Y) (t : β) (n : ) :
              (CategoryTheory.GradedObjectWithShift s C).map CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.GradedObjectWithShift s C) CategoryTheory.CategoryStruct.toQuiver (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).toPrefunctor X Y f t = f (t + n s)

              The total object of a graded object is the coproduct of the graded components.

              Instances For

                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.