After all, functors are well known! When you convert an object into another kind, surely functions in-between those objects also transform into a new breed. Let’s look at one example:

**Objects:** Topological Spaces (X)

**Functions between Objects:** Continuous maps (f)

**Objects:** Groups (G)

**Functions between Objects: ** Group Homomorphism (\( \phi \))

We wish to *convert *X into G (spaces into groups). If by some magical tool, we can do such a conversion, clearly that process will also affect the respective types of functions. We will want the f’s to get converted into (\phi )’s. The word ‘convert’ is a bit strong. In fact, it is much better to use ‘extract’ instead. [/accordion] [accordion title=”The Recipe” connect=”816″] Here is the recipe for such a conversion.

- Start with two
*reasonably nice*topological spaces X, Y. - Choose preferred points in each space; suppose \( x \in X \) and \( y \in Y \)
- Now draw loops in X starting (and ending) at x (do the same with Y).
- We will declare two loops to be
*same*if one of them can be ‘pushed nicely’ into another. In the picture, the black and red are same loops. But red and green are not! Why not? Because when you start pushing the green loop toward the red one, you are forced to give up! There is a hole in your way. - We have set of loops now. Actually, each element of the set of loops is a representative of a bunch of loops. Each pair in that bunch can be pushed easily into one another.
**Declare G = { set of (bunches of) loops in X based at x }**

What is the identity loop in G? The one that does nothing but sits at the base point. Formally, it is the constant map ( \alpha ) from a closed interval [0, 1] to the base point x. ( \alpha (t) = x \forall t\in[0,1] ) How do you combine two loops? You go along one first and then go along the other one. Clearly, this ‘combined’ loop hits the base point at least twice. But that is okay. What is the inverse loop? Just go along the same loop in the reverse direction.

# So we have extracted a group from a space!

Let us call this group (G_X ) corresponding to the space X.

Next: what happens to the functions? There were functions between topological spaces. There are functions between groups. We converted ( X \to G_X ). Similarly we may extract ( Y \to G_Y ). We are interested in a function f between X and Y. $ X \overset {f} \rightarrow Y $ After all the loops are ‘living inside’ the space X and space ‘Y’. When f takes points in X to points in Y, it is reasonable to expect that it may take loops to loops (that is members of ( G_X ) to ( G_Y ) Does it? Let us look at functions that take the preferred base point x of space X to the preferred base point y of the space Y.

What are loops? Take a segment. Bend it so that its endpoints meet at a point. Formally, it is a map ( \alpha: [0, 1] \to X ) such that ( \alpha (0) = \alpha (1) = x ) where x is the base point at which the loop is glued. Of course, instead of [0, 1], we can use any other closed interval. [0,1] is just more convenient. Anyway, so we have a formal definition of a loop. Now ‘hit’ the image [0, 1] under ( \alpha ) with the function f. ( f \cdot \alpha ) is a map from [0, 1] to Y!

After all ( f( \alpha (0) ) = f(x) = y ) (remember we are looking at functions f such as f(x) = y; that is one that takes base point to base point). Also ( f( \alpha (1) ) = f(x) = y ). This is because ( \alpha (0) = \alpha (1) = x ). Therefore the loop ( \alpha ) in X has now become a loop ( f \cdot \alpha ) in Y. Wow

Things are looking good so far. f sends loops to loops. But if you remember, our Group members are *bunches of loops that can be pushed into one another. * Does *f *send a bunch to bunch? It does! Here is how:

- Suppose a
*particular*bunch contains a Red loop (R) and a Green loop (G) . That is the red loop can be pushed into the green one. *f*sends R to some loop f(R) and G to some loop f(G) in Y (we know it sends loops to loops)- Are R’ and G’ members of the same bunch? If that happens we will be really happy! Because that would mean, not only loops are becoming loops under the effect of
*f*, but a bunch is becoming another bunch. - We can make this happen using a very simple method:
- Push the loop R a little toward the loop G. Suppose this motion, position of loop R is the loop R’
- Clearly, the loop f(R) becomes f(R’) in this process.
- Keep on pushing R toward G. At each moment, f(R) will also deform into some loop inside space Y.
- Finally, R reaches G. But then f(R) reaches f(G)! Why? Because at each moment (of pushing activity), the function
*f*was*transporting the interim loop inside X*to a loop inside Y. So the intial loop f(R) was also getting push to*somewhere.*Since the loops inside X, in the pushing process, ends up at G,*the transported loops end up at f(G).*

You have guessed it right. A little more mathematical rigor is warranted here. However, our goal is to remain conversational. So if the ‘intuition’ is clear, then the rest can be achieved. So the ‘pushing the loop’ process inside space indirectly ‘pushes the image loops’ in the target space Y. Therefore bunches go to bunches.

# Functor

Clearly f sends ( \alpha ) (a loop inside space X) to ( f \cdot \alpha ) (a loop inside space Y). Moreover, it sends bunches to bunches. We have found a map between the groups ( G_X ) and ( G_Y ) (remember, that members of (G_X) were the bunches of loops inside X and that members of (G_Y) are the bunches of loops inside Y and we found that f takes bunches to bunches). Let us call the map from ( G_X \to G_Y ) given by ( [\alpha] \to [ f \cdot \alpha ] ), by (f_*). We are using the square brackets to indicate ‘bunch’ instead of a ‘single loop’. We need to clarify whether (f_*) is a group homomorphism. We also want to know what happens to the identity element of (G_X) under (f_*).

- \(f_*\) is a group homomorphism. Why? \(f_* ([\alpha]\cdot [\beta]) = [f([\alpha]\cdot [\beta])] \). That is we are applying f to the combined loop \([\alpha]\cdot [\beta])] \). But this same as applying
*f*on \(\alpha\) and then on \(\beta\) and then combine them inside Y. That is perform \( (f \cdot \alpha) \cdot (f \cdot \beta) \). But this is in the bunch \( [f \cdot \alpha] \cdot [f \cdot \beta] \) = \(f_* ([\alpha])\cdot f_*( [\beta]) \) - Using similar arguments we have identity element of \(G_X\) going to identity element of \(G_Y \).

So clearly *f (a function between spaces) *gets converted into group homomorphism ( (f_* ) *(a function between groups).* **But we have more!** This ‘starring’ process is now converting maps between spaces into homomorphism between groups (and of-course spaces into groups) However, there are two more properties of this ‘starring’ process.

- The identity map between spaces gets converted into identity group homomorphism
- If you compose
*f and g (two maps between spaces)*and then compute the stars, it turns out, you could have computed stars of those maps first and then combined them. That is $ (f \cdot g)_{*} = f_* \cdot g_* $

It is an exercise to ‘say’ what these statements mean! Can you articulate it?

The identity map between spaces gets converted into identity group homomorphism

This one is easy but we need to be a little careful. Here **both **spaces are same: **X.** We are examining ( X \overset{f} \to X ) where f(x) = x for all ( x \in X )

Now it becomes absolutely obvious. After all, f takes *each point to itself. *Clearly, it will map each to loop to itself and hence each bunch of loops to the same bunch of loops and so on. Hence it \(f_* \) is identity group homomorphism from \( G_X \to G_X \)

$ (f \cdot g)*{ } = f* \cdot g_* $ Again we need to be careful about domain and co-domain. Here we have potentially three spaces involved! $ X \overset {g} \rightarrow Y \overset {f} \rightarrow Z $ The recipe is simple:

Start with a loop R in X

g takes that loop R to g(R) which happens to be a loop in Y

f takes the loop g(R) to the space Z, where the image is again a loop: f(g(R))

*Is this in the same bunch as \( f_*((g_* ([R])) \)*

But this is obvious because:

\( g_*([R]) = [g \cdot R ] \)

And then

\( f_*(g_*([R])) = f_*([g (R) ] ) =[ f(g(R)) ] )\)

$ \begin{array} XX & \overset {f} \rightarrow & Y \ \downarrow & & \downarrow \ G_X & \overset{f_*} \rightarrow & G_Y \end{array} $ The first row of the diagram has spaces and map between the spaces. The second row has groups and homomorphisms between the groups. Our process extracted the second row from the first row. Not only that, it did it quite *naturally:*

*I*dentity map between spaces got converted into identity homomorphism between groups.- The composition of maps between spaces led to the composition of respective homomorphisms.

This ‘process’ is a functor.