See “Computational Category Theory” by Rydeheard and Burstall for implementation, in ML, of the algorithms in elementary category theory. Following their lead, we present data types in Haskell that can be used to implement basic algorithms in category theory. We use a category in which addition (of integers) can be performed to ground the discussion. You will also need familiarity with types, type variables and classes in Haskell (see learnyouahaskell.com website) to proceed. Some of the basic algorithms will be illustrated using these datatypes in later posts, hopefully.
One can use types in Haskell to represent objects in a category. To
simplify the discussion, assume that all the objects are of the same
kind in a given category. We use a lowercase letter as
o, p to
represent objects. Arrows between objects
p' are represented
(o,p). The source of the arrow is
o, and the tail of the arrow
Consider the category in which objects are created from integers, and
arrows exist between pair of objects
o+1 to start. In this
category, there is a unique arrow between a pair of objects if one
exists. Composition of two arrows
(o+1, o+2) is is new
(o,o+2). In general, the composition of arrows
(o,o+i), (o+i,o+j) is an arrow
i < j. The identity
arrow on object
o is the identity function that returns the arrow
(o,o). In this category, we can test a pair of objects for equality,
o is not equal to
o+1. However, in a general category, pairs of
objects cannot be tested for equality. This category can be built as a
data type in Haskell. The data type for an object is declared as below.
data Obj o = Obj o deriving (Show, Eq)
The declaration allows us to create objects out of basic types such as
Obj 1 and
Obj "1", two different objects. It is up to the program to
create objects where the argument to
Obj constructor is only an
integer. Objects created such are referred to as integer objects which
cannot be compared to other types of objects like string objects
The arrow from object
a to object
(a, b). Because the arrow
between any two objects is unique, a label on the arrow is not
necessary. Instead, we declare the type for an arrow in this restricted
data Arrow o = Arrow (Obj o) (Obj o) deriving (Show, Eq)
The identity arrow on the object returns the identity arrow and is specified as the following function.
id1 (Obj o) = Arrow (Obj o) (Obj o)
Composition of arrows
(b,c) is a arrow
(a, c). Note that
a pair of arrows can only be composed when the tail of the first arrow
is the head of the second arrow. The arrow
(a,c) can be considered the
c-a. There are multiple representations of an integer. For
id1(o) for any object
o refers to the number 0. The
general strategy to compose two arrows
(a,b), (c,d) is to check if the
b is the same as object
c, in which case from a new arrow,
else return an error.
Maybe type is used for error. The result of the
composition is a
comp1 :: (Eq o) => Arrow o -> Arrow o -> Maybe (Arrow o) comp1 (Arrow a b) (Arrow c d) | b == c = Just (Arrow a d) | otherwise = Nothing
The addition is now equivalent to the composition of functions.
can be thought of as number
j. However, addition is to performed using
composition; therefore, we need to associate arrows with integers.
3can be represented as arrows
((Obj 1), (Obj 2))
((Obj 2), (Obj 5)). Composing them gives us the arrow
((Obj 1), (Obj 5)) which means
((Obj 1), (Obj 2)) with
((Obj 3), (Obj 4))
is not allowed therefore the function returns
Nothing. There are pairs
of arrows that represent 1, 3 and are not composable. One can think of
an arrow from
i > j as a negative number with the
j-i. Therefore, this category can handle negative numbers.
Think of this category as a virtual machine, expression
translated by a compiler into machine instruction
compose (Arrow (Obj 1) (Obj 4)) (Arrow (Obj 4) (Obj 8)). The machine
knows how to compose arrows and returns the results
Arrow (Obj 1) (Obj 8) which is another representation for number 7.
The result of the composition is an evaluation of the expression
This example allows for only one arrow between a pair of objects; if
there are more arrows within a pair, there is a need to label the
arrows. The datatype
NewArrow can be used to create arrows with labels
NewArrow (Obj 1) "1" (Obj 2) creates an arrow with label 1.
NewArrow (Obj 1) (\x -> x) (Obj 2) creates an arrow with a
function as the label. Function types cannot be printed (
Show is not
inherited) though in Haskell.
data NewArrow o a = NewArrow (Obj o) a (Obj o) deriving (Show, Eq)
Addition can be accomplished in a different category as well. This
category contains only a single object
() and arrows, one for each
NewArrow (Obj ()) "111" (Obj ()) represent number 3 in unary.
The composition of two arrows can be written as a new arrow with a label
which a concatenation of the two labels. This simple category on a
single object is also known as a monoid.