Notes On Categories : 1

Continued from “Notes On Categories” (14 Jul 2003) • Inquiry ListOntology 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 that 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.

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

One Response to Notes On Categories : 1

  1. Pingback: Survey of Precursors Of Category Theory • 1 | Inquiry Into Inquiry

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s