module Cat.Instances.Slice.Presheaf {o ℓ} {C : Precategory o ℓ} where

Slices of presheaf categories🔗

We prove that slices of a presheaf category are again presheaf categories. Specifically, for a presheaf, we have an isomorphism where denotes the category of elements of

An object in the slice consists of a functor together with a natural transformation To transform this data into a functor observe that for each element in the fibre is a set. But why this choice in particular? Well, observe that is essentially the total space of — so that what we’re doing here is proving an equivalence between fibrations and dependent functions! This is in line with the existence of object classifiers, and in the 1-categorical level, with slices of Sets.

In fact, since we have that latter equivalence is a special case of the one constructed here — where in the calculation below, denotes the constant presheaf The category of elements of a presheaf consists of pairs where of which there is only one choice, and

module _ {P : Functor (C ^op) (Sets Îș)} where
  private module P = Functor P

  slice-ob→presheaf
    : Ob (Slice Cat[ C ^op , Sets Îș ] P)
    → Functor (∫ C P ^op) (Sets Îș)
  slice-ob→presheaf sl .F₀ (elem x s) = el! (fibre (sl .map .η x) s)

  slice-ob→presheaf sl .F₁ eh (i , p) =
      sl .domain .F₁ (eh .hom) i
    , happly (sl .map .is-natural _ _ _) _ ·· ap (P.₁ _) p ·· eh .commute

Keeping with the theme, in the other direction, we take a total space rather than a family of fibres, with fibration being the first projection fst:

  presheaf→slice-ob : Functor (∫ C P ^op) (Sets Îș) → Ob (Slice Cat[ C ^op , Sets Îș ] P)
  presheaf→slice-ob y = obj where
    obj : /-Obj {C = Cat[ _ , _ ]} P
    obj .domain .F₀ c .∣_∣   = ÎŁ[ sect ∈ P Ê» c ] y Ê» elem c sect
    obj .domain .F₀ c .is-tr = hlevel 2
    obj .domain .F₁ f (x , p) = P.₁ f x , y .F₁ (elem-hom f refl) p
    obj .map .η x = fst

Since the rest of the construction is routine calculation, we present it without comment.

  slice→total : Functor (Slice Cat[ C ^op , Sets Îș ] P) Cat[ (∫ C P) ^op , Sets Îș ]
  slice→total = func where
    func : Functor (Slice Cat[ C ^op , Sets Îș ] P) Cat[ (∫ C P) ^op , Sets Îș ]
    func .F₀ = slice-ob→presheaf
    func .F₁ {x} {y} h .η i arg =
      h .map .η (i .ob) (arg .fst) , h .commutes ηₚ _ $ₚ arg .fst ∙ arg .snd
    func .F₁ {x} {y} h .is-natural _ _ _ = funext λ i →
      ÎŁ-prop-path! (happly (h .map .is-natural _ _ _) _)

    func .F-id    = ext λ x y p → ÎŁ-prop-path! refl
    func .F-∘ f g = ext λ x y p → ÎŁ-prop-path! refl

  slice→total-is-ff : is-fully-faithful slice→total
  slice→total-is-ff {x} {y} = is-iso→is-equiv (iso inv rinv linv) where
    inv : Hom Cat[ ∫ C P ^op , Sets _ ] _ _
        → Slice Cat[ C ^op , Sets _ ] P .Hom _ _
    inv nt .map .η i o = nt .η (elem _ (x .map .η i o)) (o , refl) .fst

    inv nt .map .is-natural _ _ f = funext λ z →
        ap (λ e → nt .η _ e .fst) (ÎŁ-prop-path! refl)
      ∙ ap fst (happly (nt .is-natural _ _
          (elem-hom f (happly (sym (x .map .is-natural _ _ _)) _))) _)

    inv nt .commutes = ext λ z w →
      nt .η (elem _ (x .map .η _ _)) (w , refl) .snd

    rinv : is-right-inverse inv (F₁ slice→total)
    rinv nt = ext λ where
      o z p → ÎŁ-prop-path! λ i →
        nt .η (elem (o .ob) (p i)) (z , λ j → p (i ∧ j)) .fst

    linv : is-left-inverse inv (F₁ slice→total)
    linv sh = trivial!

  open is-precat-iso
  slice→total-is-iso : is-precat-iso slice→total
  slice→total-is-iso .has-is-ff = slice→total-is-ff
  slice→total-is-iso .has-is-iso = is-iso→is-equiv isom where
    open is-iso
    isom : is-iso slice-ob→presheaf
    isom .inv = presheaf→slice-ob

Proving that the constructions presheaf→slice-ob and slice-ob→presheaf are inverses is mosly incredibly fiddly path algebra, so we omit the proof.