definition theorem example

Ordinary cones pick single “wires” from hom-sets; the set of cones with apex is . In an enriched setting there is no constant -functor (the unit need not be terminal), so one “smears the singularity” with a weight selecting a thicker “cylinder” in each hom-object. A weighted (indexed) limit of is defined by

and dually the weighted colimit by with . Ordinary (conical) limits are the case .

Sources: DaoFP §20.5 (“Weighted Limits”), §20.6 (“Ends as Weighted Limits”), §20.7 (“Kan Extensions”), §20.8 (“Useful Formulas”), Exercises 20.6.1, 20.6.2, 20.7.1; §20.4 (enriched Yoneda).

  • Formulas (DaoFP Exercise 20.6.2): and (power and copower, Kan Extension).
  • Ends as weighted limits (§20.6): for , with the hom-functor as weight; proof by the Yoneda trick, Fubini and ninja Yoneda over . Dually (DaoFP Exercise 20.6.1). This defines ends and coends in the enriched setting.
  • Kan extensions as weighted (co)limits (§20.7): and (DaoFP Exercise 20.7.1) — the weights are representables, replacing the functor from the terminal category used for ordinary (co)limits.
  • Enriched Yoneda (§20.4): weak form (a set of -natural transformations vs. the global elements of ); strong form as an object of , using the internal hom.

Docs: FinSets · Limits & colimits

using Catlab
# a weighted limit in Set with a discrete shape J = {1, 2}: lim^W D = ∏_j (W j ⋔ D j) = ∏_j D j^{W j}
D = [FinSet(2), FinSet(3)]; W = [2, 1]            # weights = sizes of W j
prod(length(D[j])^W[j] for j in 1:2)              # 2^2 · 3^1 = 12 elements
# conical limit (W = Δ1) is the plain product: 2 · 3 = 6
ob(product(D))
import Mathlib
open CategoryTheory
-- Mathlib has ordinary (conical) limits; weighted limits appear through ends / Kan extensions
#check @CategoryTheory.Limits.limit
#check @CategoryTheory.Functor.ran            -- (Ran_P F) e = lim^{B(e, P-)} F
{-# LANGUAGE RankNTypes #-}
-- a weighted cone with apex x: a natural transformation W ⇒ C(x, D-), i.e. for each j
-- a function from the weight W j to arrows x -> D j; in Hask with W j = weights as types:
type WeightedCone w d x = forall j. w j -> (x -> d j)