There is an engineer and a mathematician in each of us. My blog posts, for instance, alternate between discussing write ordering in the x86 processor, and explaining abstract ideas from category theory. I might be a bit extreme in this respect, but even in everyday programming we often switch between the focused, low-level, practical thinking of an engineer and the holistic, global, abstract thinking of a mathematician. Sometimes we write a for loop; sometimes we holistically apply `std::transform`

to a vector. Sometimes we write imperative step-by-step programs; and sometimes we write declarative ones, letting the compiler figure out the steps.

What I find fascinating is that these two approaches also manifest themselves in mathematics. There are constructive proofs that resemble the work of an engineer; and there are proofs of existence, that resemble the work of a philosopher. An entity may be defined by showing how to construct it, or it might be defined by its universal property — by being the most general or the most specific among its peers. A universal description is favored by category theorists, especially if it reduces their dependency on Set Theory. It’s not that category theorists hate set theory, but they definitely like to limit their reliance on it.

In this post I’ll show you the two ways of defining a free monoid. If the term *monoid* is not familiar to you, don’t despair; it’s a very simple construct, and you’ve seen it and used it many times. The classic example of a monoid is the set of strings with string concatenation. Another is the set of natural numbers with addition (or multiplication — either will work).

# Free Monoid

A monoid is a set with a binary operation — let’s just call it multiplication and denote it by the infix `*`

(you’ll also see it called, in Haskell, `mappend`

, `++`

, `<>`

…). This binary operation must obey certain laws. The first law is that there is a special element called unit, `e`

, with the property that for any `a`

:

a * e = e * a = a

(You’ll also see it called `mempty`

.) The second law is that of associativity:

a * (b * c) = (a * b) * c

There are many examples of monoids, but there is a special class of them called *free* monoids. The easiest way to understand what a free monoid is, is to construct one. Just pick a set, any set, and call it the set of *generators*. Then define multiplication in the laziest, dumbest possible way. First, add one more element to the set and call it a unit. Define multiplication by unit to always return the other multiplicand. Then, for every pair of generators create a new element and call it their product. Define products of products the same way — every time you need to multiply two existing elements, create a new one, call it their product, and add it to the growing set. The only tricky part is to make sure that thusly defined product is associative. So for every triple of elements, a, b, and c, you have to identify a * (b * c) with (a * b) * c.

Here’s a little mnemonic trick that may help you keeping track of associativity. Assign letters of the alphabet to your generators. Say, you have less than 26 generators and you call them `a`

, `b`

, `c`

, etc. Reserve letter `z`

for your unit element. When asked for the product of, say, `a`

and `t`

, call it `at`

. The product of `c`

and `at`

will be `cat`

, and so on. This way, you’ll automatically call the product of `ca`

with `t`

, `cat`

, as you should.

As you can see a free monoid generated by an alphabet is equivalent to the set of strings, with product defined as string concatenation.

What happens when your original set has just one element, say `a`

? The free monoid based on this set would contain the unit `z`

and all the powers of `a`

of the form `aaa...`

. Writing long strings of `a`

s is boring, so instead let’s just length-encode them: `a`

as 1, `aa`

as 2, and so on. It’s natural to assign zero to `z`

. We have just reinvented natural numbers with “product” being the addition.

Lists are free monoids too. Take any finite or infinite set and create ordered lists of its elements. Your unit element is the empty list, and “multiplication” is the concatenation of lists. Strings are just a special type of lists based on a finite set of generators. But you can have lists of integers, 3-D points, or even lists of lists.

Not all monoids are free, though. Take for instance addition modulo 4. You start with four elements: 0, 1, 2, and 3. But the sum of 2 and 3 is 1 (5 mod 4). Were it a free monoid, 2+3 would be a totally new element, but here we identified it with the existing element 1.

The question is, can we obtain any monoid by identifying some elements of the corresponding free monoid? The modulo 4 monoid, for instance, could be obtained by identifying all natural numbers that have the same remainder when divided by 4.

The answer is yes, and it’s an example of a very important notion in category theory called universality. A free monoid is universal. Here’s what it means: I have a set of generators and a free monoid built from it. Give me *any* monoid and select any elements in it to correspond to the generators of my free monoid. I can show you a unique mapping *m* of my free monoid to your monoid that not only maps my generators to your selected elements, but also preserves multiplication. In other words, if a * b = c in my monoid, then m(a) * m(b) = m(c) in your monoid.

Notice that the mapping might not cover the whole target monoid. It might cover a sub-monoid. But within that sub-monoid, for each element in my monoid there will be a corresponding element in yours. In general, multiple elements in my monoid may be mapped to a single element in yours. This way your monoid has the same structure as mine, except that some elements have been identified.

Any monoid can be obtained from a free monoid by identifying some elements.

# Categorical Monoid

You might find the above theorem in a category theory text (see, for instance, Saunders Mac Lane, Categories for the Working Mathematician, Corollary 2 on p. 50) and not recognize it. That’s because category theoreticians don’t like treating monoids as sets of elements. They prefer to see a monoid as a shapeless object whose properties are encoded in morphisms — arrows from a monoid to itself.

How do we reconcile these two views of monoids? On the one hand you have a set of elements with multiplication, on the other hand a monolithic blob with arrows.

Here’s one way: Consider what happens when you pick one element of a monoid and apply it to all elements — say, by left multiplication. You get a function acting on this set (in Haskell we call this function an operator section). That’s your morphism. Notice that you can compose such morphisms just like you compose functions: left multiplication by “a” composed with left multiplication by “b” is the same function as left multiplication by “a * b”. The set of these morphisms/functions — one for each element — together with the usual function composition — tells you everything about the monoid. It gives you the categorical description of it: A monoid is a category with a single object (“mono” means one, single) and a bunch of morphisms acting on it.

There is also a bigger Category of Monoids, where monoids are the objects and morphisms map monoids into monoids preserving their structure (they map products into products). Some of these monoids are free, others are not.

We know how to construct a free monoid starting from a set of generators, but how can we tell which of the abstract blobs with morphisms is free and which isn’t? And how do we even begin talking about generators if we vowed not to view monoids as sets?

# Universal Construction

We have to work our way back from abstract monoids to sets. But to do that we need a functor because we’re going between categories. Our source is the category of monoids, and our target is the category of sets, where objects are sets and morphisms are regular functions.

Just a reminder: A *functor* is a mapping between categories. It maps objects into objects and morphisms into morphisms; but not willy-nilly — it has to preserve composition. So if one morphism is a composition of two others, it’s image under the functor must also be the composition of the two images.

In our case we will be mapping the category of monoids into the category of sets. But once you mapped a monoid into a set (its, so called, *underlying* set), you have forgotten its structure. You have forgotten that some functions were “special” because they corresponded to the morphisms of the original monoid. All functions are now equal. This kind of functor that forgets structure is aptly called a *forgetful functor*.

Our goal is to describe a free monoid corresponding to a set of generators X. X is just a regular set, nothing fancy, but we can’t look for it inside a monoid because a monoid is not a set any more. Fortunately we have our forgetful functor U, which maps monoids into sets. So instead of looking for generators inside monoids (which we can’t do), we’ll look for them inside those underlying sets. Given a monoid M, we just pick a function p: X -> U M. The image of X under p will serve as candidate generators.

Now let’s take another monoid L and do the same thing. We map our generators into the set U L (the set obtained from L using the same forgetful functor U). Call this mapping h: X -> U L. Now, U is a functor, so it maps monoids to sets and monoid *morphisms* to functions. So if there is a morphism m from M to L, there is a corresponding function from U M to U L (we’ll call this function U m). This is just a function mapping the set that’s underlying one monoid into the set that’s underlying another monoid.

The first set, U M, contains the images of our generators under p. Our function U m will map those candidate generators into some set in U L. Now, U L also contains candidate generators — the images of X under h. What are the chances that those two sets are the same? Slim but not zero! If we can pick m so that they overlap, we will have come as close as possible to the idea of the two monoids “sharing the same generators.” (See the following illustration.)

So given two monoids M and L and a set of generators X we can create candidate sets of generators in U M and U L. If we’re lucky, we can find a monoid morphism m that maps M to L and whose projection using U maps one candidate set of generators into the other.

Now zoom out to the category of monoids and draw an arrow between any M and L whenever such m exists. What you’ll find out, to your great amazement, is that there is one unique monoid (up to an isomorphism) that has all arrows going out and none coming in. This universal monoid is *the* free monoid constructed from the set of generators X. The two completely different descriptions converge!

# Conclusion

How does it work? What’s the intuition behind it?

A lot of mathematicians secretly (or not so secretly) subscribe to Plato’s philosophy. A monoid is a Platonic object that can’t be observed directly, but which can cast a shadow on the wall of the cave we live in. This shadow is the underlying set: the result of a forgetful functor. The morphisms between monoids preserve their nature; theirs shadows, though, are mere functions.

Functions may be invertible, but often they conflate elements together. So if you have a flow of functions from one set to a bunch of others, they will tend to smooth out the differences, collapse multiple elements into one. So if there is one shadow of a monoid that dominates all others that are sharing the same generators — and there always is one — it must be the shadow of the free one. It is the one that has the largest selection of distinct elements, since every multiplication produces a new element (mitigated only by the requirements of associativity and the need for the unit).

# Appendix: A Bonus Free Object

Free monoid is an example of a larger class of *free objects*. Free object is a powerful notion in category theory that generalizes the idea of a *basis*. Instead of the category of monoids let’s take any category that supports a faithful functor into the category of sets. A *faithful* functor is a functor that maps distinct morphism into distinct functions — it doesn’t mash them together. This will be our forgetful functor U. It maps an object A from our category to a set U A; and we can inject our basis X into this set, just like we did with generators. Object A is called universal if, for any other object B and any injection of X into U B, there is a unique morphism from A to B that “preserves” the basis. Again, by preserving the basis we mean that the image of our morphism under U maps one injected basis into the other.

December 26, 2013 at 3:28 am

For me it looks like the relation between set and morphism you are referring to, are like space and dual space in linear algebra.

December 27, 2013 at 5:07 pm

Reblogged this on narenbabuin.

January 10, 2014 at 6:55 pm

Haskell nitpick: The monoid unit is mempty, not mzero.

January 10, 2014 at 7:24 pm

@Dan: Thanks, corrected.

May 5, 2014 at 11:31 am

[…] used the same method in my previous blog, Understanding Free Monoids. There, the free monoid was picked as a universal object in the category of monoids. We considered […]

October 10, 2014 at 1:22 am

[…] Understanding Free Monoids and Universal Constructions […]

October 10, 2014 at 1:02 pm

Instead of reserving z as the unit object, wouldn’t the empty string “” be a more intuitive and useful candidate?

October 11, 2014 at 1:04 am

@Catherine Ray: The problem with this would be that we are not used to empty names. Imagine talking about this monoid on the phone. You have to give this element some name. But you’re right, I was hinting at the string monoid as a model for all free monoids. The empty string is the unit.

March 9, 2023 at 10:57 am

Hi, I’m not quite understand about:

“Given a monoid M, we just pick a function p: X -> U M. The image of X under p will serve as candidate generators”

What does X and mapping p looks like?

X map to pX, then pX generate UM?

Is sizeof(X)>sizeof(pX)?

Is sizeof(X)>sizeof(UM)? If not, can we map one element of X to multiple elements of UM?

March 9, 2023 at 12:16 pm

It’s a function, so it can map multiple elements to one, but not the other way around.

March 9, 2023 at 5:08 pm

so, when we say Σ is a alphabet, e is empty string, + is string concatenation, then <Σ*, +, e> is a monoid from the view of Set.

Is X or pX means the Σ?

March 10, 2023 at 1:32 am

X is the alphabet. p embeds this alphabet into the (underlying set of the) free monoid. Every letter of the alphabet is mapped into a on-character string. These strings are the generators. You can get any string by concatenating them.

March 10, 2023 at 8:12 pm

Yes, p may be a kleene star operation, what I don’t understand is kleene star operation, says f, f: V->V*. But This mapping seems like mapping a small V into a large set V*?

March 11, 2023 at 2:03 am

p is just a regular function and it maps X to a small subset of the big X*. It picks the set of generators in it. You may think of the Kleene star as taking this subset and generating the rest of the free monoid. Kleene star is not a function, though.