---
title: Computing Limits in Concrete Categories
module: Limits and Colimits
moduleNumber: 4
lessonNumber: 4
order: 404
summary: >
  In Set the limit of any diagram is the set of threads: choice functions
  through the nodes that commute with every edge. In Pos, Mon, and Top the
  recipe is the same limit downstairs plus the unique structure that makes the
  projections structure-preserving — pointwise order, componentwise operations,
  the topology generated by the projections. The pattern is what "the forgetful
  functor creates limits" means concretely.
topics: [Limits and Colimits]
sources:
  - book: Simmons
    ref: "Ch. 4 §4.6 How to calculate certain limits; §4.6.1 Set; §4.6.2 Pos; §4.6.3 Mon; §4.6.4 Top"
  - book: Barr & Wells
    ref: "Ch. 9 — Limits and colimits, examples"
draft: false
---

The [definition of a limit](/category-theory/limits-colimits/limits) is a
universal property, not a formula. In $\mathbf{Set}$ and in categories of
structured sets a single two-step recipe supplies the formula: take the limit of
underlying sets, then put the unique compatible structure on it. This is why
limits in $\mathbf{Pos}$, $\mathbf{Mon}$, $\mathbf{Grp}$, and $\mathbf{Top}$ all
"look like" limits in $\mathbf{Set}$, and why colimits in those categories do
not.

## Threads: the limit formula in Set

Fix a diagram in $\mathbf{Set}$: a shape with nodes $i, j, k, \ldots$ and edges
$e : i \to j$, instantiated by sets $A(i)$ and functions $A(e) : A(i) \to
A(j)$. If a limit $L$ exists, the
[representable description](/category-theory/limits-colimits/limits) forces its
elements:

$$
L \;\cong\; \mathbf{Set}(1, L) \;\cong\; \{\text{cones on } A \text{ with vertex } 1\},
$$

and a cone with one-point vertex is a choice of one element per node,
compatible with every edge.[^lein-thought]

> **Definition (Choice function, thread).** A **choice function** for the
> family $(A(i))_{i}$ is a function $a$ assigning to each node $i$ an element
> $a(i) \in A(i)$. A **thread** is a choice function such that
> $$
> A(e)\bigl(a(i)\bigr) = a(j)
> \qquad \text{for every edge } e : i \to j.
> $$

A choice function picks one element from each set; a thread picks them
_compatibly_, so that traveling along any edge carries the selected element to
the selected element. When the shape has no edges every choice function is a
thread, and the set of threads is the full product $\prod_i A(i)$.

> **Theorem (Limits in Set).** For any diagram $(A, A(e))$, the set $L$ of all
> threads, with the evaluation maps $\alpha(i) : L \to A(i)$, $a \mapsto a(i)$,
> is a limit of the diagram.[^sim-thread]

> **Proof.** The evaluations form a cone: for an edge $e : i \to j$ and a thread
> $a$, $\bigl(A(e) \circ \alpha(i)\bigr)(a) = A(e)(a(i)) = a(j) = \alpha(j)(a)$.
> For universality, let $\bigl(\xi(i) : X \to A(i)\bigr)_i$ be any cone. A
> mediating map must satisfy $\alpha(i) \circ \mu = \xi(i)$, i.e. $\mu(x)(i) =
> \xi(i)(x)$, which determines $\mu$ uniquely; and this $\mu(x)$ is a thread
> because the cone condition $A(e)(\xi(i)(x)) = \xi(j)(x)$ is precisely the
> thread condition at $x$. Existence and uniqueness both fall out of the same
> line. $\square$

$$
% caption: A thread through a diagram in Set: one element chosen per node, and
% every edge carries choice to choice. The limit is the set of all threads.
\begin{tikzpicture}[scale=1.0, >=stealth, font=\footnotesize]
\definecolor{acc}{HTML}{4A6FA5}
% three node-sets as vertical bars
\foreach \x in {0, 3.0, 6.0} {
  \draw[black] (\x,0) rectangle (\x+1.0,2.6);
}
\node[black, anchor=south] at (0.5,2.65) {$A(i)$};
\node[black, anchor=south] at (3.5,2.65) {$A(j)$};
\node[black, anchor=south] at (6.5,2.65) {$A(k)$};
% other elements
\fill[black] (0.5,2.1) circle (1.4pt);
\fill[black] (0.5,0.5) circle (1.4pt);
\fill[black] (3.5,2.2) circle (1.4pt);
\fill[black] (6.5,0.6) circle (1.4pt);
% the thread
\fill[acc] (0.5,1.3) circle (2pt);
\fill[acc] (3.5,1.1) circle (2pt);
\fill[acc] (6.5,1.6) circle (2pt);
\draw[->, acc, thick] (0.62,1.28) -- (3.38,1.12);
\draw[->, acc, thick] (3.62,1.13) -- (6.38,1.57);
\node[acc, font=\scriptsize] at (2.0,1.55) {$A(e)$};
\node[acc, font=\scriptsize] at (5.0,1.7) {$A(f)$};
\node[acc, anchor=north, font=\scriptsize] at (3.5,-0.15) {a thread: $A(e)(a(i)) = a(j)$};
\end{tikzpicture}
$$

The thread set is a subset of the product $\prod_i A(i)$ cut out by one
equation per edge — the concrete face of the
[products-and-equalizers generation theorem](/category-theory/limits-colimits/products-equalizers-pullbacks).
Instantiating the shape recovers every formula seen so far:

| Shape | Threads | Limit |
| --- | --- | --- |
| discrete | all choice functions | product $\prod_i A(i)$ |
| $\bullet \rightrightarrows \bullet$ | $\{x \mid s(x) = t(x)\}$ | equalizer |
| corner $\bullet \to \bullet \leftarrow \bullet$ | $\{(x,y) \mid s(x) = t(y)\}$ | pullback |
| $\cdots \to X_2 \to X_1 \to X_0$ | compatible sequences | inverse limit |

> **Worked example.** Take the corner shape $i \to k \leftarrow j$ with $A(i) =
> \{1, 2\}$, $A(j) = \{p, q\}$, $A(k) = \{\bullet, \circ\}$, and edges $A(e)(1) =
> \bullet$, $A(e)(2) = \circ$, $A(f)(p) = \bullet$, $A(f)(q) = \bullet$. A thread
> chooses $a(i), a(j), a(k)$ with $A(e)(a(i)) = a(k)$ and $A(f)(a(j)) = a(k)$, so
> the middle value is forced by either leg. Choosing $a(i) = 1$ forces $a(k) =
> \bullet$, which needs $a(j) \in \{p, q\}$; choosing $a(i) = 2$ forces $a(k) =
> \circ$, which no $a(j)$ hits. The threads are
> $$
> (1, p, \bullet) \qquad \text{and} \qquad (1, q, \bullet),
> $$
> so the thread set $\{(1, p), (1, q)\}$ is the pullback $A(i) \times_{A(k)}
> A(j)$: a subset of the product $A(i) \times A(j)$ cut out by the single
> edge-compatibility equation.

$$
% caption: An inverse limit as compatible sequences: each set maps to the one
% before it, and the limit L projects onto every stage so that each leg lands on
% the reduced value.
\begin{tikzpicture}[scale=1.0, >=stealth, font=\footnotesize]
\definecolor{acc}{HTML}{4A6FA5}
\node (X0) at (0,0) {$X_0$};
\node (X1) at (2.1,0) {$X_1$};
\node (X2) at (4.2,0) {$X_2$};
\node (X3) at (6.3,0) {$X_3$};
\fill[black] (7.55,0) circle (0.7pt);
\fill[black] (7.85,0) circle (0.7pt);
\fill[black] (8.15,0) circle (0.7pt);
\draw[->, black] (X1) -- (X0) node[midway, above] {$r_0$};
\draw[->, black] (X2) -- (X1) node[midway, above] {$r_1$};
\draw[->, black] (X3) -- (X2) node[midway, above] {$r_2$};
\draw[->, black] (7.3,0) -- (X3) node[midway, above] {$r_3$};
\node[acc] (L) at (3.15,2.3) {$L$};
\draw[->, acc, thick] (L) -- (X0);
\draw[->, acc, thick] (L) -- (X1);
\draw[->, acc, thick] (L) -- (X2);
\draw[->, acc, thick] (L) -- (X3);
\end{tikzpicture}
$$

## The lifting recipe

Now let $\mathcal{C}$ be a category of structured sets with a forgetful functor
$U : \mathcal{C} \to \mathbf{Set}$ — posets and monotone maps, monoids and
homomorphisms, spaces and continuous maps. Given a diagram in $\mathcal{C}$,
apply $U$ to get a diagram in $\mathbf{Set}$, and compute its thread set $L$.
The remaining work is always the same three steps.[^sim-recipe]

```algorithm
caption: $\textsc{LiftLimit}$ — compute a limit in a category of structured sets
input: a diagram $(A, A(e))$ in $\mathcal{C}$ with forgetful functor $U$
$L \gets$ set of threads of the underlying $\mathbf{Set}$-diagram
furnish $L$ with the unique $\mathcal{C}$-structure making every evaluation $\alpha(i)$ a $\mathcal{C}$-arrow
verify each $\alpha(i)$ is a $\mathcal{C}$-arrow // gives a cone in $\mathcal{C}$
for each cone $\xi$ in $\mathcal{C}$ with vertex $X$ do
  $\mu \gets$ the unique $\mathbf{Set}$-mediator, $\mu(x)(i) = \xi(i)(x)$
  verify $\mu$ is a $\mathcal{C}$-arrow // the only step using structure of $X$
return $(L, \alpha)$
```

Downstairs in $\mathbf{Set}$ only one function can serve as the mediator, so
the only open question is whether that function respects the structure. Each
category contributes one idea to the "furnish" step.

$$
% caption: The two phases of the recipe: forget the diagram down to Set and read
% off its thread set, then furnish that set with the one structure making every
% evaluation an arrow of C.
\begin{tikzpicture}[scale=1.0, >=stealth, font=\footnotesize,
  bx/.style={draw, minimum width=32mm, minimum height=11mm, align=center}]
\definecolor{acc}{HTML}{4A6FA5}
\node[bx, draw=acc, text=acc, thick] (top) at (0,2.2) {diagram in $\mathcal{C}$};
\node[bx] (bot) at (0,0) {diagram in $\mathbf{Set}$};
\node[bx] (thr) at (5.4,0) {thread set $L$};
\node[bx, draw=acc, text=acc, thick] (lift) at (5.4,2.2) {$L$ with structure};
\draw[->, black] (top) -- (bot) node[midway, right] {$U$};
\draw[->] (bot) -- (thr) node[midway, above] {threads};
\draw[->, acc, thick] (thr) -- (lift) node[midway, right] {furnish};
\end{tikzpicture}
$$

### Pos: pointwise order

For a diagram of posets and monotone maps, order the threads **pointwise**:

$$
a \leq b \iff a(i) \leq b(i) \text{ for all nodes } i.
$$

Antisymmetry is inherited from the components. Each evaluation $\alpha(i)$ is
monotone by construction, and the mediator $\mu$ is monotone because each
$\xi(i)$ is: $x \leq y$ gives $\xi(i)(x) \leq \xi(i)(y)$ for every $i$, which
is exactly $\mu(x) \leq \mu(y)$ in the pointwise order.[^sim-pos]

### Mon: componentwise operations

Threads over a diagram of monoids multiply **componentwise**, $(a \star{}
b)(i) = a(i)\,b(i)$, with unit the thread of units $1(i) = 1_i$. The product of
two threads is again a thread because each $A(e)$ is a homomorphism:

$$
A(e)\bigl((a \star{} b)(i)\bigr) = A(e)\bigl(a(i)\bigr)\,A(e)\bigl(b(i)\bigr)
= a(j)\,b(j) = (a \star{} b)(j).
$$

Associativity and the unit laws hold pointwise, the evaluations are
homomorphisms by definition of $\star{}$, and the mediator is a homomorphism
because every $\xi(i)$ is.[^sim-mon] The same componentwise furnishing works
for $\mathbf{Grp}$, $\mathbf{Ab}$, $\mathbf{Ring}$, $\mathbf{Vect}_k$, and any
similar algebraic category: in $\mathbf{Vect}_k$, for instance, $(x_I)_I +
(y_I)_I = (x_I + y_I)_I$.

> **Worked example.** Take the product of $(\mathbb{Z}/2, +)$ and $(\mathbb{Z}/3,
> +)$ over the discrete two-object shape. The underlying thread set is $\{0, 1\}
> \times \{0, 1, 2\}$, six elements, and the componentwise operation is
> $$
> (a_1, a_2) \star (b_1, b_2) = (a_1 + b_1 \bmod 2,\ a_2 + b_2 \bmod 3),
> $$
> with unit $(0, 0)$. The projections onto each coordinate are homomorphisms by
> construction. The element $(1, 1)$ has order $\operatorname{lcm}(2, 3) = 6$, so
> it generates all six threads: the product monoid is the cyclic group
> $\mathbb{Z}/6$, matching the isomorphism $\mathbb{Z}/2 \times \mathbb{Z}/3 \cong
> \mathbb{Z}/6$.

### Top: the projection-generated topology

For a diagram of spaces, topologize the thread set by declaring, for each node
$i$ and each open $U \subseteq A(i)$, the preimage $\alpha(i)^{-1}(U)$ to be
open, and taking these as a **subbase**. This is the smallest topology making
every evaluation continuous. Smallness is what makes the mediator continuous:
for a subbasic open set,

$$
\mu^{-1}\bigl(\alpha(i)^{-1}(U)\bigr) = \xi(i)^{-1}(U),
$$

which is open since $\xi(i)$ is continuous — and subbasic preimages are all one
needs to check.[^sim-top] The two conditions pull in opposite
directions: continuity of the projections needs the topology large, continuity
of mediators needs it small, and the generated topology is the unique
equilibrium. For a discrete shape this is precisely the product topology, whose
familiar "smallest topology with continuous projections" definition is thus a
special case of a limit computation.

### A worked pullback in Top

Take the cospan in $\mathbf{Top}$, writing $J = [0, 2\pi)$ for the half-open
interval:

$$
J \xrightarrow{\; s \;} S^1 \xleftarrow{\; t \;} \mathbb{R},
\qquad
s(\theta) = (\cos\theta, \sin\theta),
\qquad
t(x) = (\cos x, \sin x).
$$

- **Underlying set.** Threads for the corner shape are pairs, so $P = \{
  (\theta, x) \mid s(\theta) = t(x) \}$, i.e. pairs with $x = \theta + 2\pi n$
  for some integer $n$.
- **Topology.** The subbase is generated by the two projections into $J$ and
  $\mathbb{R}$, which is the subspace topology from the product $J \times
  \mathbb{R}$.
- **Result.** $P$ is a disjoint union of copies of $J$ indexed by $n \in
  \mathbb{Z}$ — the pullback splits the real line into the sheets it wraps over
  the circle, one component per winding.

$$
% caption: The pullback of the interval $J = [0, 2\pi)$ and the line over the
% circle: pairs that agree on the circle form one sheet per winding number.
\begin{tikzpicture}[scale=1.0, >=stealth, font=\footnotesize]
\definecolor{acc}{HTML}{4A6FA5}
% circle at bottom center
\draw[black, thick] (3.1,0.4) circle (0.55);
\node[black, anchor=north] at (3.1,-0.3) {$S^1$};
% interval upper left
\draw[acc, thick] (0.2,2.6) -- (1.8,2.6);
\node[acc, anchor=south] at (1.0,2.68) {$J$};
% real line upper right
\draw[acc, thick] (4.4,2.6) -- (6.2,2.6);
\node[acc, anchor=south] at (5.3,2.68) {$\mathbb{R}$};
% maps down
\draw[->, black] (1.2,2.45) -- (2.8,1.05);
\node[black] at (1.7,1.6) {$s$};
\draw[->, black] (5.1,2.45) -- (3.4,1.05);
\node[black] at (4.6,1.6) {$t$};
% pullback sheets above
\foreach \y in {3.7,4.2,4.7} \draw[acc, thick] (2.3,\y) -- (3.9,\y);
\node[acc, anchor=west, font=\scriptsize] at (4.05,4.2) {$P$: one sheet per winding};
\draw[->, black] (2.15,4.2) -- (1.15,2.78);
\draw[->, black] (4.0,3.62) -- (5.15,2.78);
\end{tikzpicture}
$$

## Creation of limits

In each case the $\mathbf{Set}$-limit admitted exactly one structure making the
projections structure-preserving, and the resulting cone was a limit cone
upstairs. That is the definition of
[**creating limits**](/category-theory/limits-colimits/limits-and-functors); the
forgetful functors of $\mathbf{Pos}$, $\mathbf{Mon}$, $\mathbf{Grp}$,
$\mathbf{Ring}$, $\mathbf{Vect}_k$ all create limits, and since $\mathbf{Set}$
is complete, all these categories are complete with limit-preserving forgetful
functors.[^lein-create]

$\mathbf{Top}$ sits just outside the pattern: the underlying set of a limit of
spaces is the limit of underlying sets, but the topology is not unique — any
topology between the generated one and the discrete one keeps the projections
continuous, and only the generated one is universal. The forgetful functor
$\mathbf{Top} \to \mathbf{Set}$ preserves limits without creating them. The
distinction is invisible when computing (the recipe still says "use the
generated topology") but it changes the formal status of the lift:

| Category | Furnishing on threads | Forgetful functor |
| --- | --- | --- |
| $\mathbf{Pos}$ | pointwise order | creates limits |
| $\mathbf{Mon}$, $\mathbf{Grp}$, $\mathbf{Vect}_k$ | componentwise operations | creates limits |
| $\mathbf{Top}$ | projection-generated topology | preserves, does not create |

On the colimit side the recipe collapses. The underlying set of a coproduct of
groups is not the disjoint union of underlying sets, and the initial object of
$\mathbf{Grp}$ (one element) does not sit over the initial object of
$\mathbf{Set}$ (empty). Colimits of algebras exist, but they must be built with
free constructions and quotients, not lifted from below — except in the
[directed case](/category-theory/limits-colimits/colimits), where eventual
agreement computes them elementwise after all. The forgetful functor preserves
limits but not colimits, and the reason is **adjunctions**, developed in
[interactions between functors and limits](/category-theory/limits-colimits/limits-and-functors)
and completed in
[right adjoints preserve limits](/category-theory/adjoints-limits/adjoints-preserve-limits).

[^lein-thought]: **Leinster**, _Basic Category Theory_, §5.1, Example 5.1.22 — the thought experiment computing $\lim D \cong \mathbf{Set}(1, \lim D)$ as cones with one-point vertex, yielding the compatible-families formula (5.16).
[^sim-thread]: **Simmons**, _An Introduction to Category Theory_, §4.6.1, Definitions 4.6.1–4.6.4 and Theorem 4.6.6 — choice functions, threads, and the proof that the thread set with evaluations is the limit in $\mathbf{Set}$.
[^sim-recipe]: **Simmons**, _An Introduction to Category Theory_, §4.6 — the two-phase method: compute the limit in $\mathbf{Set}$, then furnish it so the evaluations and mediators are arrows of the parent category.
[^sim-pos]: **Simmons**, _An Introduction to Category Theory_, §4.6.2 — the pointwise order on threads, monotonicity of evaluations, and the monotone mediator.
[^sim-mon]: **Simmons**, _An Introduction to Category Theory_, §4.6.3 — the componentwise monoid structure on threads and the verification that mediators are homomorphisms; extended to $\mathbf{CMon}$, $\mathbf{Grp}$, $\mathbf{Rng}$ in Exercise 4.6.4. The $\mathbf{Vect}_k$ form is Leinster, Example 5.1.23.
[^sim-top]: **Simmons**, _An Introduction to Category Theory_, §4.6.4 — the subbase of projection-preimages and the equality $\mu^{-1}(\alpha(i)^{-1}(U)) = \xi(i)^{-1}(U)$ giving continuity of the mediator; Leinster, Example 5.1.24.
[^lein-create]: **Leinster**, _Basic Category Theory_, §5.3, Example 5.3.4, Definition 5.3.5 and Lemma 5.3.6 — the unique group structure on a product of underlying sets, creation of limits, and completeness of algebraic categories via creation; Example 5.3.2 for $\mathbf{Top}$ preserving but not reflecting.