## Notes On Categories • 1

#### Continued from “Notes On Categories” (14 Jul 2003) • Inquiry List • Ontology List

NB.  This page is a work in progress.  I will have to dig up some still older notes from the days of pen and paper before I can remember how I left things last.

Here are some notes on a computational approach to category theory I started working on back in the 1980s, all of which work as yet remains in the “Schubert Category” of unfinished symphonies.

It helps me a little bit to write the names of categories in the plural, so as not to confuse them with individuals.  It also helps if I treat the arrows of Arr(C) as the primary entities in the category C, recovering the objects of Obj(C) as secondary entities by collecting all the entities that appear in s(f) = Source(f) and t(f) = Target(f) as one ranges over all of the arrows f in Arr(C).

The last time that I tried to do “categories by computer”, I was using data structures that had the following shapes:

```   Category C o
/|\
/ | \
... | ...
|
Arrow f o
/ \
s   t
/     \
s(f) o       o t(f)
```

A functor, then, is something I picture like this:

```                   Functor F o
. | .
.   |   .
.     |     .
.       |       .
Category C o         o         o Category D = CF
|       ./ \.       |
|     . /   \ .     |
|   .  /     \  .   |
| .   /       \   . |
Arrow f o    o         o    o Arrow fF
/ \ .   .     .   . / \
/  .\      . .      /.  \
s .   t     . .     s   . t
/.      \  .     .  /      .\
o         o         o         o
x         y         xF        yF
```

This is a rough sketch of the actual data structures that I used to represent a functor F as a “matching” between the parallel items of categories C and D.

NB.  I have reverted to the convention I was accustomed to use at the time, where all operators are applied on the right of their arguments.

What the picture says is that the functor F : CCF takes each arrow f in C to an arrow fF in CF, and each object x in C to an object xF in CF, in such a manner that (fs)F = (fF)s and (ft)F = (fF)t.  To be a functor, F must satisfy the following two systems of equations:

(1x)F   =   1(xF),   for all x in Obj(C).

(fg)F   =   fFgF,   for all composable f, g in Arr(C).

That was just how I kept track of things on the computer.

It is, of course, more usual to draw a functor square in the following manner, where we get one such picture for each object x and arrow f in C.

```            F
x o-------->o xF
|         |
|         |
f |         | fF
|         |
v         v
y o-------->o yF
F
```
This entry was posted in Abstraction, Category Theory, Computing, Graph Theory, Logic, Mathematics, Relation Theory, Type Theory and tagged , , , , , , , . Bookmark the permalink.

### 4 Responses to Notes On Categories • 1

This site uses Akismet to reduce spam. Learn how your comment data is processed.