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 : C → CF 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:

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