Product and Sum in Category Theory

Even if you are not a functional programmer, the notion of product type should be familiar to you, e.g., Pair<A, B> in Java is a product type of A and B. But the definition in category theory is not that easy to comprehend. Here is how it is defined on Wikipedia:

Let C be a category with some objects X1 and X2. A product of X1 and X2 is an object X (often denoted X1 × X2) together with a pair of morphisms π1 : X → X1, π2 : X → X2 that satisfy the following universal property: for every object Y and pair of morphisms f1 : Y → X1, f2 : Y → X2 there exists a unique morphism f : Y → X1 × X2 such that the following diagram commutes:

Why is it defined that way and how do we interpret it? Let me translate it into something that Java programmers can understand. The definition actually says, if X1 x X2 is a product type of X1 and X2 with two functions π1 : X -> X1 and π2 : X -> X2, there must be a unique function f : Y -> X1 × X2 which satisfies the property: for any value y of type Y, function f1 : Y -> X1 and a function f2 : Y -> X2, the equations π1(f(y)) == f1(y) and π2(f(y)) == f2(y) must always be true.

In other words, if I define my product type as usual like:

// Java
class Pair<X1, X2> {
  private final X1 x1;
  private final X2 x2;
  public Pair(X1 x1, X2 x2) {
    this.x1 = x1;
    this.x2 = x2;
  }
  public X1 getX1() {
    return x1;
  }
  public X2 getX2() {
    return x2;
  }
}

There must be a unique f which is constructed by:

// Java
Function<Y, Pair<X1, X2>> makeF(Function<Y, X1> f1, Function<Y, X2> f2) {
  return (Y y) -> new Pair(f1.apply(y), f2.apply(y));
}

In other words, product type guarantees that if you have a function of type Y -> X1 and a function of type Y -> X2, you must have a unique function of type Y -> X1 x X2 satisfying the property. The property can be expressed programatically as: for any y, f1 and f2, the following test must pass.

// Java
void testProductType(Y y, Function<Y, X1> f1, Function<Y, X2> f2) {
  Function<Y, Pair<X1, X2>> f = makeF(f1, f2);
  assert(f.apply(y).getX1() == f1.apply(y));
  assert(f.apply(y).getX2() == f2.apply(y));
}

So what could be a counterexample? Here is:

// Java
class Pair<X1, X2> {
  private final X1 x1;
  private final X2 x2;
  public Pair(X1 x1, X2 x2) {
    this.x1 = x1;
    this.x2 = x2;
  }
  public X1 getX1() {
    return 1;
  }
  public X2 getX2() {
    return 2;
  }
}

With this wrong definition of product type, you cannot possibly construct such a f which satisfies the universal property, i.e., there are always some cases which can make the test fail.

If you think it is done, here comes the tricky part, is the type below a product type?

// Java
class Pair<X1, X2> {
  private final X1 x1;
  private final X2 x2;
  public Pair(T x1, U x2) {
    this.x1 = x1;
    this.x2 = x2;
  }
  public T getX1() {
    return x1 + 1;
  }
  public T getX2() {
    return x2 + 2;
  }
}

Intuition may tell you it is not a product type, but by definition of product type in the category theory, it actually is. Why? Because you can define a unique f satisfying the property:

// Java
Function<Y, Pair<X, Y>> makeF(Function<Y, X1> f1, Function<Y, X2> f2) {
  return (Y y) -> new Pair(f1.apply(y) - 1, f2.apply(y) - 2);
}

What this means is that, the two product types are equivalent in category theory. This is because category theory defines equivalence by structure, if two things have the same structure, they are considered the same thing.

Then, what about sum type (a.k.a coproduct type)? The definition in category theory is:

Let C be a category and let X1 and X2 be objects in that category. An object is called the coproduct of these two objects, written X1 ∐ X2 or X1 ⊕ X2 or sometimes simply X1 + X2, if there exist morphisms i1 : X1 → X1 ∐ X2 and i2 : X2 → X1 ∐ X2 satisfying a universal property: for any object Y and morphisms f1 : X1 → Y and f2 : X2 → Y, there exists a unique morphism f : X1 ∐ X2 → Y such that f1 = f ∘ i1 and f2 = f ∘ i2. That is, the following diagram commutes:

From program perspective, the definition says, if X1 ∐ X2 is a sum type of X1 and X2 with two functions i1 : X1 -> X1 ∐ X2 and i2 : X2 → X1 ∐ X2, there must be a unique function f : X1 ∐ X2 -> Y which satisfies the property: for any value y : Y, function f1 : X1 -> Y and function f2 : X2 -> Y, the equations f(i1(y)) == f1(y) and f(i2(y)) == f2(y) must always be true.

If I define sum type as below:

// Java
class Either<X1, X2> {
  private final Optional<X1> x1;
  private final Optional<X2> x2;
  private Either(Optional<X1> x1, Optional<X2> x2) {
    this.x1 = x1;
    this.x2 = x2;
  }
  public static Either<X1, X2> left(X1 x1) {
    return new Either(Optional.of(x1), Optional.absent());
  }
  public static Either<X1, X2> right(X2 x2) {
    return new Either(Optional.absent(), Optional.of(x2));
  }
  public Optional<T> getX1() {
    return x1;
  }
  public Optional<U> getX2() {
    return x2;
  }
}

There must be a unique f which is constructed by:

// Java
Function<Either<X1, X2>, Y> makeF(Function<X1, Y> f1, Function<X2, Y> f2) {
  return (Either<X1, X2> e) -> e.getX1().isPresent() ? f1.apply(e.getX1().get()) : f2.apply(e.getX2().get());
}

In other words, sum type guarantees that if you have a function of type X1 -> Y and a function of type X2 -> Y, you must have a unique function of type X1 ∐ X2 -> Y satisfying the property. The property can be verified programatically as: for any x1, x2, f1, f2 the following tests must pass.

// Java
void testSumType(X1 x1, X2 x2, Function<X1, Y> f1, Function<X2, Y> f2) {
  assert(f.apply(Either.left(x1)) == f1.apply(x1));
  assert(f.apply(Either.left(x2)) == f2.apply(x2));
}

To sum up, category theory defines product and sum type by requiring them to be able to construct such a function which satisfies a universal property.