# Monoid

In abstract algebra, a branch of mathematics, a **monoid** is a set equipped with an associative binary operation and an identity element.

Monoids are semigroups with identity. Such algebraic structures occur in several branches of mathematics.

For example, the functions from a set into itself form a monoid with respect to function composition. More generally, in category theory, the morphisms of an object to itself form a monoid, and, conversely, a monoid may be viewed as a category with a single object.

In computer science and computer programming, the set of strings built from a given set of characters is a free monoid. Transition monoids and syntactic monoids are used in describing finite-state machines. Trace monoids and history monoids provide a foundation for process calculi and concurrent computing.

In theoretical computer science, the study of monoids is fundamental for automata theory (Krohn–Rhodes theory), and formal language theory (star height problem).

See semigroup for the history of the subject, and some other general properties of monoids.

A set *S* equipped with a binary operation *S* × *S* → *S*, which we will denote •, is a **monoid** if it satisfies the following two axioms:

In other words, a monoid is a semigroup with an identity element. It can also be thought of as a magma with associativity and identity. The identity element of a monoid is unique.^{[1]} For this reason the identity is regarded as a constant, i. e. 0-ary (or nullary) operation. The monoid therefore is characterized by specification of the triple (*S*, • , *e*).

Depending on the context, the symbol for the binary operation may be omitted, so that the operation is denoted by juxtaposition; for example, the monoid axioms may be written (*ab*)*c* = *a*(*bc*) and *ea* = *ae* = *a*. This notation does not imply that it is numbers being multiplied.

A **submonoid** of a monoid (*M*, •) is a subset *N* of *M* that is closed under the monoid operation and contains the identity element *e* of *M*.^{[2]}^{[3]} Symbolically, *N* is a submonoid of *M* if *N* ⊆ *M*, *x* • *y* ∈ *N* whenever *x*, *y* ∈ *N*, and *e* ∈ *N*. In this case, *N* is a monoid under the binary operation inherited from *M*.

A subset *S* of *M* is said to *generate* *M* if the smallest submonoid of *M* containing *S* is *M*. If there is a finite set that generates *M*, then *M* is said to be a **finitely generated monoid**.

A monoid whose operation is commutative is called a **commutative monoid** (or, less commonly, an **abelian monoid**). Commutative monoids are often written additively. Any commutative monoid is endowed with its *algebraic* preordering ≤, defined by *x* ≤ *y* if there exists *z* such that *x* + *z* = *y*.^{[4]} An *order-unit* of a commutative monoid *M* is an element *u* of *M* such that for any element *x* of *M*, there exists *v* in the set generated by *u* such that *x* ≤ *v*. This is often used in case *M* is the positive cone of a partially ordered abelian group *G*, in which case we say that *u* is an order-unit of *G*.

A monoid for which the operation is commutative for some, but not all elements is a trace monoid; trace monoids commonly occur in the theory of concurrent computation.

The monoid axioms imply that the identity element *e* is unique: If *e* and *f* are identity elements of a monoid, then *e* = *ef* = *f*.

As a special case, one can define nonnegative integer powers of an element *x* of a monoid: *x*^{0} = 1 and *x*^{n} = *x*^{n−1} • *x* for *n* ≥ 1. Then *x*^{m+n} = *x*^{m} • *x*^{n} for all *m*, *n* ≥ 0.

An element *x* is called invertible if there exists an element *y* such that *x* • *y* = *e* and *y* • *x* = *e*. The element *y* is called the inverse of *x*. Inverses, if they exist, are unique: If *y* and *z* are inverses of *x*, then by associativity *y* = *ey* = (*zx*)*y* = *z*(*xy*) = *ze* = *z*.^{[8]}

If *x* is invertible, say with inverse *y*, then one can define negative powers of *x* by setting *x*^{−n} = *y*^{n} for each *n* ≥ 1; this makes the equation *x*^{m+n} = *x*^{m} • *x*^{n} hold for all *m*, *n* ∈ **Z**.

The set of all invertible elements in a monoid, together with the operation •, forms a group.

Not every monoid sits inside a group. For instance, it is perfectly possible to have a monoid in which two elements a and b exist such that *a* • *b* = *a* holds even though b is not the identity element. Such a monoid cannot be embedded in a group, because in the group multiplying both sides with the inverse of a would get that *b* = *e*, which is not true.

A monoid (*M*, •) has the cancellation property (or is cancellative) if for all a, b and c in M, the equality *a* • *b* = *a* • *c* implies *b* = *c*, and the equality *b* • *a* = *c* • *a* implies *b* = *c*.

A commutative monoid with the cancellation property can always be embedded in a group via the *Grothendieck group construction*. That is how the additive group of the integers (a group with operation +) is constructed from the additive monoid of natural numbers (a commutative monoid with operation + and cancellation property). However, a non-commutative cancellative monoid need not be embeddable in a group.

If a monoid has the cancellation property and is *finite*, then it is in fact a group.^{[9]}

The right- and left-cancellative elements of a monoid each in turn form a submonoid (i.e. are closed under the operation and obviously include the identity). This means that the cancellative elements of any commutative monoid can be extended to a group.

The cancellative property in a monoid is not necessary to perform the Grothendieck construction – commutativity is sufficient. However, if a commutative monoid does not have the cancellation property, the homomorphism of the monoid into its Grothendieck group is not injective. More precisely, if *a* • *b* = *a* • *c*, then b and c have the same image in the Grothendieck group, even if *b* ≠ *c*. In particular, if the monoid has an absorbing element, then its Grothendieck group is the trivial group.

An **inverse monoid** is a monoid where for every *a* in *M*, there exists a unique *a*^{−1} in *M* such that *a* = *a* • *a*^{−1} • *a* and *a*^{−1} = *a*^{−1} • *a* • *a*^{−1}. If an inverse monoid is cancellative, then it is a group.

In the opposite direction, a *zerosumfree monoid* is an additively written monoid in which *a* + *b* = 0 implies that *a* = 0 and *b* = 0:^{[10]} equivalently, that no element other than zero has an additive inverse.

Let *M* be a monoid, with the binary operation denoted by • and the identity element denoted by *e*. Then a (left) ** M-act** (or left act over

*M*) is a set

*X*together with an operation ⋅ :

*M*×

*X*→

*X*which is compatible with the monoid structure as follows:

This is the analogue in monoid theory of a (left) group action. Right *M*-acts are defined in a similar way. A monoid with an act is also known as an *operator monoid*. Important examples include transition systems of semiautomata. A transformation semigroup can be made into an operator monoid by adjoining the identity transformation.

A homomorphism between two monoids (*M*, ∗) and (*N*, •) is a function *f* : *M* → *N* such that

where *e*_{M} and *e*_{N} are the identities on *M* and *N* respectively. Monoid homomorphisms are sometimes simply called **monoid morphisms**.

In contrast, a semigroup homomorphism between groups is always a group homomorphism, as it necessarily preserves the identity (because, in a group, the identity is the only element such that *x* ⋅ *x* = *x*).

A bijective monoid homomorphism is called a monoid isomorphism. Two monoids are said to be isomorphic if there is a monoid isomorphism between them.

Monoids may be given a *presentation*, much in the same way that groups can be specified by means of a group presentation. One does this by specifying a set of generators Σ, and a set of relations on the free monoid Σ^{∗}. One does this by extending (finite) binary relations on Σ^{∗} to monoid congruences, and then constructing the quotient monoid, as above.

Given a binary relation *R* ⊂ Σ^{∗} × Σ^{∗}, one defines its symmetric closure as *R* ∪ *R*^{−1}. This can be extended to a symmetric relation *E* ⊂ Σ^{∗} × Σ^{∗} by defining *x* ~_{E} *y* if and only if *x* = *sut* and *y* = *svt* for some strings *u*, *v*, *s*, *t* ∈ Σ^{∗} with (*u*,*v*) ∈ *R* ∪ *R*^{−1}. Finally, one takes the reflexive and transitive closure of *E*, which is then a monoid congruence.

Monoids can be viewed as a special class of categories. Indeed, the axioms required of a monoid operation are exactly those required of morphism composition when restricted to the set of all morphisms whose source and target is a given object.^{[12]} That is,

*A monoid is, essentially, the same thing as a category with a single object.*

More precisely, given a monoid (*M*, •), one can construct a small category with only one object and whose morphisms are the elements of *M*. The composition of morphisms is given by the monoid operation •.

Likewise, monoid homomorphisms are just functors between single object categories.^{[12]} So this construction gives an equivalence between the category of (small) monoids **Mon** and a full subcategory of the category of (small) categories **Cat**. Similarly, the category of groups is equivalent to another full subcategory of **Cat**.

In this sense, category theory can be thought of as an extension of the concept of a monoid. Many definitions and theorems about monoids can be generalised to small categories with more than one object. For example, a quotient of a category with one object is just a quotient monoid.

Monoids, just like other algebraic structures, also form their own category, **Mon**, whose objects are monoids and whose morphisms are monoid homomorphisms.^{[12]}

There is also a notion of monoid object which is an abstract definition of what is a monoid in a category. A monoid object in **Set** is just a monoid.

In computer science, many abstract data types can be endowed with a monoid structure. In a common pattern, a sequence of elements of a monoid is "folded" or "accumulated" to produce a final value. For instance, many iterative algorithms need to update some kind of "running total" at each iteration; this pattern may be elegantly expressed by a monoid operation. Alternatively, the associativity of monoid operations ensures that the operation can be parallelized by employing a prefix sum or similar algorithm, in order to utilize multiple cores or processors efficiently.

In addition, any data structure can be 'folded' in a similar way, given a serialization of its elements. For instance, the result of "folding" a binary tree might differ depending on pre-order vs. post-order tree traversal.

An application of monoids in computer science is so-called MapReduce programming model (see ). MapReduce, in computing, consists of two or three operations. Given a dataset, "Map" consists of mapping arbitrary data to elements of a specific monoid. "Reduce" consists of folding those elements, so that in the end we produce just one element.

For example, if we have a multiset, in a program it is represented as a map from elements to their numbers. Elements are called keys in this case. The number of distinct keys may be too big, and in this case the multiset is being sharded. To finalize reduction properly, the "Shuffling" stage regroups the data among the nodes. If we do not need this step, the whole Map/Reduce consists of mapping and reducing; both operation are parallelizable, the former due to its element-wise nature, the latter due to associativity of the monoid.

A **continuous monoid** is an ordered commutative monoid in which every directed set has a least upper bound compatible with the monoid operation:

These two concepts are closely related: a continuous monoid is a complete monoid in which the infinitary sum may be defined as

where the supremum on the right runs over all finite subsets E of I and each sum on the right is a finite sum in the monoid.^{[16]}