Abstract Algebra

Meta out the wazoo: Monads and Monoids

goodmath — Tue, 11 Mar 2008 09:57:26 +0000

Meta out the wazoo: Monads and Monoids

Since I mentioned the idea of monoids as a formal models of computations, John
Armstrong made the natural leap ahead, to the connection between monoids and monads - which are
a common feature in programming language semantics, and a prominent language feature in href="http://scienceblogs.com/goodmath/goodmath/programming/haskell/">Haskell, one of my favorite programming languages.

Monads are a category theoretic construction. If you take a monoid, and use some of the constructions we've seen in the last few posts, we can move build a meta-monoid; that is,
a monoid that's built from monoid-to-monoid mappings - essentially, the category of
small categories. (Small categories are categories whose collection of objects are a
set, not a proper class.)

We're going to look at constructs built using objects in that category. But first (as usual), we need to come up with a bit of notation. Suppose we have a category, C. In the category of categories, there's an identity morphism (which is also a functor) from C to C. We'll
call that 1_C. And given any functor from T:C→C (that is, from C to itself),
we'll say that exponents of that functor are formed by self-compositions of T: T²=TºT; T³=TºTºT, etc. Finally, given a functor T,
there's a natural transformation from T to T, which we'll call 1_T.

So, now, as I said, a monad is a construct in this category of category - that is, a particular
category with some additional structure built around it. Given a category, C, a monad on C
consists of three parts:

T:C→C, a functor from C to itself.
A natural transformation, η:1_C→T
A natural transformation μ:T²→T

C, T, η, and μ must satisfy some coherence conditions, which
basically mean that they must make the following two diagrams commute. First, we
show a requirement that in terms of natural transformations, μ is commutative in
how it maps T² to T:

And then, a commutativity requirement on μ and η with respect to T (basically
making μ and η into a meta-identity for this meta-monoid):

μ and η basically play the role of turning C into a meta-meta-monoid. A monoid is
basically a category; then we play with it, and construct the category of categories - the first
meta-monoid. Now we're taking a self-functor of the meta-monoid, and and using natural
transformations to build a new meta-meta-monoid around it.

One of the key things to notice here is that we're building a monoid whose objects are,
basically, functions from monoids to monoids. We've gone meta out the wazoo - but it's given us
something really interesting.

We start with the category. From the category, we get the functor - a structure preserving map
from the category to itself. The monad focuses on the functor - the transition from C to C: using
natural transformations, it defines an equivalence - not an equality, but an equivalence - between
multiple applications of the functor and a single application.

In terms of programming languages, we can think of C as a state. An application
of the functor T is an action - that is, a mapping from state to state. What the monad
does is provide a structure for composing actions. We don't need to write the state - it's
implicit in the definition of the functor/action. The monad says that if we have an action "X" and an action "Y", we can compose them into an action "X followed by Y". What the natural transformation says is that "X followed by Y" is an action - we can compose sequences of
actions, and the result is always an action - which we can compose further, producing other
compound actions.

So at the bottom, we have functions that are state-to-state transformers. But we don't
really need to think much about the complexity of a state-to-state transition. What
we can do instead is provide a collection of primitive actions - which are themselves
written as state-to-state transitions - and then use those primitives to build
imperative code - which remains completely functional under the covers, and yet has
all of the properties that we would want from an imperative programming system -
ordering, updatable state, etc.

Below is a really simple piece of Haskell code using the IO monad. What the monad does is play
with IO states. The category is the set of IO states. Each action is a transformation from state to
state. The state is invisible -- it's created at the beginning of the "do", and each
subsequent statement is implicitly converted to a state transition function.

hello :: IO ()
hello =
  do
    print "What is your name?"
    x <- getLine
    print (concat ["Hello", x])

So in the code above, "print "What is your name""is an action from an IO state to an IO state. It's composed with x <- getLine - which is, implicitly,
another transition from an IO state to an IO state, which includes an implicit variable
definition; and that's composed with the finat "print". The actions are sequenced - they occur in the correct order, and each passes its result state to next action. The monad
lets us program completely in terms of the actions, without worrying about how to pass the states.

goodmath Tue, 03/11/2008 - 05:57

Tags

Abstract Algebra

category theory

Haskell

programming

Mark, good stuff on category theory as usual.

Talking about John Armstrong, I think it would be helpful for other readers if you could add his blog to your blogroll (I think you just overlooked that.)

Now here's something I didn't realize until one of the students in my category theory seminar last semester helped tease apart: a Haskell monad is actually not a monad. It's a closely related structure called at "Kleisli triple". There's a way of going back and forth between monads and triples, but the data you give in a Haskell program is actually that of the triple corresponding to the monad we're thinking of.

> a Haskell monad is actually not a monad

Here is the documentation for Monad in the Haskell libraries:

http://cvs.haskell.org/Hugs/pages/libraries/base/Control-Monad.html

Due to a silly mistake in the library, Monad doesn't derive from Functor, but everyone who needs it defines a Functor instance for their monads. So we have an endofunctor, and two natural transformations, return and join. return and join are supposed to satisfy the equations satisfied by eta and mu in a monad. So I'm a bit confused about why you say Haskell monads aren't really monads.

John:

a Haskell monad is actually not a monad. It's a closely related structure called at "Kleisli triple".

As I understand it, the notions are isomorphic until you get to 2-categories.
However, there is some historical justification, in that Haskell Monads as originally posed used fmap/return/join as the basis functions rather than fmap/return/bind.

The category you discuss here - the category of IO states with arrows being state transitions - is all nice and well, but it's not the category "normally" considered in Haskell code descriptions; and Haskell Monads are monads in the rather different category Hask of Haskell datatypes with functions as morphisms as well.

Thus, IO is a functor that takes a datatype to a datatype encoding IO actions. And the monad structure on IO basically tells us that once we've started allowing changes to the World State, we can re-declare our intent to allow changes to the World State without really changing anything.

Is there a good way to view the state categories we get in IO (and in the State monad) as ... collapsed subcategories of Hask, with all objects in IOState collapsed to the datatype classed objects in IO Hask? It seems like there should be potential for a "categorification" process here where a state-ish datatype gets blown up to a large subcategory of state transitions encoded using some sort of virtual type thingies...

Monoids and Computation: Syntactic Monoids

goodmath — Thu, 06 Mar 2008 20:39:19 +0000

Monoids and Computation: Syntactic Monoids

While doing some reading on rings, I came across some interesting stuff about
Monoids and syntax. That's right up my alley, so I decided to write a post about that.

We start by defining a new property for monoids - a kind of equivalence
relation called a monoid congruence. A Monoid congruence defines
equivalence classes within the set of values in a monoid. The monoid congruence
relation is generally written as "~", and it's a relation between two values in a
monoid: ~⊆M×M. A monoid congruence has all of the usual properties
of an equivalence relation: it's symmetric, reflexive, and transitive. It also
respects the monoid operator: if a, b, c, and d are all members of a monoid M,
a~c, and b~d, then aºb~cºd.

If we have a monoid congruence relation "~", then we can obviously use it to create a collection of equivalence classes, called congruence classes. If a is a member of monoid (M,º), then we can define the congruence class [a]={m∈M | x~a } - that is, the set of objects in M that are "~" with a.

We can then define a new operation on the congruence classes: if a and b are members of a monoid (M,º), then we can define an operation "*" by
[a]*[b]=[aºb]. If you look at the set of congruence classes of M given by "~", and the "*", what do you get? Another monoid, which we call a quotient monoid. The quotient monoid created by a particular congruence relation "~" is
written M/~.

Now, we take a new step, and this is where it starts to get really interesting. Remember how I described the relationship between monoids and computing devices? We're going to start taking advantage of that. If we take a monoid, and use concatenation
as the notation for the monoid operator, then we can describe products as strings: "abc" is (aºb)ºc.

In automata theory, we talk about formal languages, which are specific sets of strings of symbols. A formal language is usually described by some system of rules, which describe
how the strings in the language are generated. For a very simple example, we can
use a regular expression, like "a⁺b^*" to represent the language consisting of any number of "a"s, possibly followed by any number of "b"s. We can
talk about more complicated languages, by using grammars. For example, the classic
first language that can't be described by simple regular expressions is the following:

X → (X)
X → X X
X → ε

This language consists of sequences of open and close parens where the number of opens and closes is balanced: strings like "()", "(())", "((()(()(()))))", and so on.

If we think of a monoid as a meta-computing machine, then we can
talk about the kinds of languages that can be accepted by a particular
monoid - that is, if we're working with a machine built from the monoid, what kinds of languages can that machine accept? It turns out that we can define that
set using monoid quotients!

We can start by defining a syntactic quotient, using contatenation to denote the monoid operator. If M is a monoid, and S is a subset of M,
then we can define left and right syntactic quotients of S:

If m∈M, then the right syntactic quotient of S by m,
written S/m = { a∈M | am ∈ S }.
If n∈M, then the left syntactic quotient of S by n,
written n\S = { b∈M | mb∈S }.

We can then use the syntactic quotients to define congruence relations,
exactly as we did above. We get two congruence relations, the right syntactic equivalence, ~s, which is the congruence relation induced by the right syntactic quotient, and the left syntactic equivalence s~, which is the congruence relation implied by the left syntactic quotient. And finally, we can define a total syntactic congruence (also called a double-sided congruence), written ~_s using both:

a ~_s b ⇔ (∀x,y∈M: xay∈S ⇔ xby∈S

So, here's where the connection to computable languages comes in. The syntactic quotient, following the procedure above, defines a new monoid - the syntactic monoid of S, which we call M(S). The syntactic monoid of S is a monoid which accepts
the set S. We call a language - consisting of the strings of symbols that
concatenated together by M's monoid operator result in values in S. So we've finally really gotten to the point where we can really see how a monoid represents a computing device. In computation theory, we can describe every computing device in terms of languages. We can likewise describe computable languages in terms of monoids.

In particular, we can define what it means for a language to be recognizable by a
monoid, M. Take a language, L⊆M. If the set of quotients {L/m|m∈M} is finite,
then L is recognizable by M.

There's more to it than this - transition monoids are particularly interesting. But that's enough for this post. We'll save it for later.

goodmath Thu, 03/06/2008 - 15:39

Tags

Abstract Algebra

computation

Ideals - Abstract Integers

goodmath — Tue, 04 Mar 2008 08:58:50 +0000

Ideals - Abstract Integers

When I first talked about rings, I said that a ring is an algebraic
abstraction that, in a very loose way, describes the basic nature of integers. A ring is a full abelian group with respect to addition - because the integers
are an abelian group with respect to addition. Rings add multiplication with an
identity - because integers have multiplication with identity. Ring multiplication doesn't include an inverse - because there is no multiplicative inverse in
the integers.

But a ring isn't just the set of integers with addition and multiplication. It's an abstraction, and there are lots of thing that fit that abstraction beyond the basic realization of the ring of integers. So what are the elements of those
things? They can be pretty much anything - there are rings of topological spaces,
rings of letters, rings of polynomials. But can we use the abstraction of
the ring to create an abstraction of an object that resembles an integer, rather than an abstraction that resembles the set of all integers?

Obviously, the answer is yes, or I wouldn't be asking it, right?

The answer is something called an ideal. Ideals capture some of the essence of an integer within the set of integers; there are prime ideals that
capture the essence of prime numbers within a ring.

Suppose we have a ring, (A,+,×). We can define a special subset,
R, such that (R,+) is a subgroup of (A,+), and ∀r∈R, ∀a∈A:
r×a∈R - in other words, R is a subgroup of A, and R is closed
over A with respect to multiplication when a member of R is the right operand. If that is true, then R is a right ideal of A.

We can do the same thing again, only require the subset to be closed with respect to multiplication when any member of A is the left operand; that's called a left ideal.

An two-sided ideal I is a subset of a ring which is both a left ideal and a
right ideal of the ring. A proper ideal is an ideal that is a proper
subset of its ring. In general, when we just say ideal, we mean "two-sided proper ideal".

The idea of an ideal of a ring is easiest to grasp by looking at
a couple of examples using the integers. This is a lot easier to grasp given an example. We know that the set Z of all integers is a ring using addition and multiplication. The set of all even integers is an ideal, usually written 2Z. Given any member of
2Z, you can multiply it by any integer, and you'll get a result that's a member of 2Z. We can say that 2Z is, in some sense, a representation of the number 2 within the ring of integers - it's the set of values that can be generated from 2 using multiplication. Similarly, 3Z is the set of all integer multiples of 3, and we can say that it's a representation of the number 3.

The easiest way to see how an ideas works as a sort of prototypical integer is by looking at prime ideals. An ideal I of a commutative ring R is prime if and only if for every a,b∈R, if a×b∈I, then either a∈I or b∈I. That's an abstract way of saying something that works out to the definition of prime numbers in integers. A number is prime if and only if every multiple of it must be the product of two numbers, at least one of which is a multiple of the prime. So, for example, 7 is prime: you can't get a multiple of seven except by multiplying something by seven. But 6 isn't prime: you can multiply 4 by 9 and get 36 - 36 is a multiple of 6, but neither 4 nor 9 are multiples of 6.

That leads us to an equivalent of prime factors of the integers. We know
that in the integers, every integer can be uniquely defined as the product of a collection of prime numbers. Similarly, if you take a ring, R, and the set of prime ideals of that ring, then every ideal of R can be uniquely defined as a product of prime ideals.

goodmath Tue, 03/04/2008 - 03:58

Tags

Abstract Algebra

Nice post. But your last statement isn't entirely true: Only Dedekind domains have the property that proper ideals factor into a product of prime ideals. See http://en.wikipedia.org/wiki/Dedekind_domain

Thanks, this brings me closer to an understanding of the abstract properties of rings.

Is there a reasonably clear example of a ring that is not composed of integers (knots?), perhaps one that has prime ideals?

Mark Dow:

Sure. Polynomials. Polynomials form a ring with respect to
addition and multiplication. Prime ideals are based on non-factorable polynomials. Every polynomial is either a multiple of primes, or it's a prime itself.

In many cases polynomials (or other power series) works as bases - and what do you know, I googled and found polynomial rings, polynomials with coefficients from a ring.

Dunno what they are good for though. The wikipage speaks in mathish. Any translators here? Or better examples?

Ah, crossposting.

And, um, of course power series can work as bases. What I was wondering about was the goodies the wikipedia page threw in as extra spice. Never mind.

R is a subgroup of A, and R is closed over A with respect to multiplication when a member of R is the right operand.

A right ideal R is closed under right multiplication by elements from A.

From some reason your algebra mistakes stick out in my mind, like misstating the group axioms or saying a dense ordering is the defining property of the continuum. They were pointed out, but not fixed.

Dunno what they are good for though. The wikipage speaks in mathish. Any translators here? Or better examples?

Polynomial rings are my favorite example -- they're fundamental to algebraic geometry. Ideals have a very geometric meaning in that realm; let's look at the polynomial ring in 2 variables with coefficients in the complex numbers, C[x,y].

Suppose you have an ideal generated by one polynomial, f(x,y). Geometrically, we can think of this as defining a subset of C2, call it V, given by the equation f(x,y)=0 (we work in the complex realm to guarantee solutions). Now the ideal generated by f(x,y) is the set of all polynomials P(x,y) that are multiples of f: P(x,y)=p(x,y)f(x,y). But that means P=0 whenever f=0, so the ideal is simply the set of polynomials which vanish on V (I'm assuming f is not a power of another polynomial here).

In this scenario, prime ideals have a special meaning -- prime ideals correspond to irreducible subsets V (if f(x,y) factors, each factor defines a component of V). And you can extend to ideals generated by more than one polynomial to construct intersections of these geometric objects.

In algebraic geometry we abstract this idea, and end up identifying a geometric object with the ideal of polynomials which vanish on that object, allowing us to treat algebra and geometry as one and the same.

Davis:

Thanks for that. One of the problems I'm having writing these articles lately is that I'm getting far outside my comfort zone. I know that the good examples of rings and ideals are in algebraic geometry - but I've never studied algebraic geometry, and I don't have the time to learn it. So I'm struggling to find examples.

In algebraic geometry we abstract this idea, and end up identifying a geometric object with the ideal of polynomials which vanish on that object,

Just to make sure, like the 1-dim sphere as x^2+y^2 -1 = 0? So from bases to basic objects?

My favorite example of ideals involves the ring of continuous functions on â, C(â), with standard addition and multiplication of functions. It is not difficult to verify that Ia={fâC(â) | f(a)=0 } is an ideal for any aââ. This ideal is, in fact prime and maximal, which is most easily shown by recognizing that C(â)/Ia is isomorphic to the reals, which is a field.

Just to make sure, like the 1-dim sphere as x^2+y^2 -1 = 0? So from bases to basic objects?

Exactly like that, yes. That equation corresponds to an ideal generated by the polynomial x^2+y^2-1.

Incidentally, you can form the basis for a topology on C2 by declaring these sorts of objects to be the closed sets. The empty set corresponds to the non-proper ideal generated by the constant polynomial f(x,y)=1 (if you examine the definition of an ideal, you'll note any ideal containing 1 must contain the entire ring); the entire space corresponds to the ideal generated by the constant polynomial g(x,y)=0 (0 is the only thing in this ideal). This is the Zariski topology, which is mighty weird -- if you play a little, you'll discover that the open sets are all huge!

Thanks for that. One of the problems I'm having writing these articles lately is that I'm getting far outside my comfort zone.

No problem. I love to talk algebraic geometry to anyone who'll listen. :)

Thanks Davis (and Mark)! I think I finally got the idea of ideals abstracted away from the basic case, and why they matter in the general case.

Come back, Mr. Algebraic Geometer!

You said that the factors of f(x,y) correspond to the components of its variety. I've been wondering for awhile if one cannot use the standard topology (on R^n or C^n for instance) instead of the Zariski topology for some of the classification concerning irreducible components.

I've been wondering for awhile if one cannot use the standard topology (on R^n or C^n for instance) instead of the Zariski topology for some of the classification concerning irreducible components.

What exactly did you have in mind? The Zariski topology is strictly coarser than the standard topology (Zariski-open implies standard-open), so you can probably do most things with the standard topology as well. The idea is for it to encode only the "algebraic" open and closed sets, though, so moving to the standard topology means drifting away from algebra.

If you want something finer than Zariski but still algebraic, it's worth looking into the Ã©tale topology (which is much more difficult to grasp).

Interesting. Thanks. If I'm not mistaken, however, Rings don't have to have multiplicative identities. That would be a Ring with unity. But if you are far from your comfort zone, I can't even see my comfort zone from here. So you might want to check if what I said is right!

Long time since the last time I read this blog, and when I read this post I just remembered a question I made myself when I studied something on these abstract objects for the first time... where are the names of algebraic structures come from?, I mean, why something like (A,+,Ã) is called "a ring"?

I hope I'm not being disappointing ;)

"... The word ring is short for the German word 'Zahlring' (number ring). The French word for a ring is anneau, and the modern German word is Ring, both meaning (not so surprisingly) 'ring.' Fraenkel (1914) gave the first abstract definition of the ring, although this work did not have much impact. The term was introduced by Hilbert... "

Weisstein, Eric W. "Ring." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/Ring.html

How many different rings are there with n elements? [extra credit if you can say exactly what I mean by "different"]. Here's a table if we restrict ourselves to rings with 1.

http://www.research.att.com/~njas/sequences/A037291

A037291 Number of rings with 1 containing n elements.

n a(n)
11
21
31
44
51
61
71
811
94
101
111
124
131
141
151
1650
171
184
191
204
211
221
231
2411
254
261
2712
284
291
301
311
32208
331
341
351
3616
371
381
391
4011
411
421
431
444
454
461
471
4850
494
504
511
524
531
5411
551
5611
571
581
591
604
611
621
634

LINKS
C. Noebauer, Home page

CROSSREFS
Cf. A027623 [number of rings with n elements], A037221 [Number of near-rings (or nearrings) definable on cyclic group of order n].

KEYWORD
nonn,nice,hard

AUTHOR
Christian G. Bower (bowerc(AT)usa.net), Jun 15 1998.

EXTENSIONS
a(16) and a(32)-A(63) from Christof Noebauer (christof.noebauer(AT)algebra.uni-linz.ac.at), Sep 29, 2000

COMMENT

Here a ring means (R,+,*):
(R,+) is abelian group,
* is associative, a*(b+c) = a*b+a*c, (a+b)*c = a*c+b*c.
Need not contain "1",
* need not be commutative.

Is infinity an ideal of Z, the integers? I ask because I am wondering if Z/infinity is a ring. If not, why not please.

> Is infinity an ideal of Z, the integers? I ask because I am wondering
> if Z/infinity is a ring

No. Infinity isn't an integer (or even a real number), so there's no such thing as 'the ideal generated by infinity'.

So there's no such object as Z/infinity. But even if there was, it's probably just be the same as Z -- after all, Z/(n) is isomorphic to Z modulo n; and "Z modulo infinity" doesn't look that different from Z to me.

(BTW: For anyone wondering, no, that last sentence wasn't actually *expressely* written to send pure mathematicians (aka 'pedants') into paroxysms of anger -- that's just a nice side-effect ;-) )

Full Circle: the Categorical Monoid

goodmath — Thu, 28 Feb 2008 12:28:29 +0000

Full Circle: the Categorical Monoid

By now, we've seen the simple algebraic monoid, which is essentially an
abstract construction of a category. We've also seen the more complicated, but interesting monoidal category - which is, sort of, a meta-category - a category built using categories. The monoidal category is a fairly complicated object - but it's useful.

What does a algebraic monoid look like in category theory? The categorical monoid is a complex object - a monoid built from monoids. If we render the algebraic monoid in terms of a basic category, what do we get? A monoid is, basically, a category with one object. That's it: every algebraic monoid is a single object category.

But we can do something more interesting than that. We know what a monoidal category looks like. What if we take a monoidal category, and express the fundamental concept of a monoid in it?

The result is the categorical monoid, also known as a categorical monoid object. It's really very simple. Take a monoidal category. If you recall, in a monoidal category, we've got a "tensor" operation, ⊗;
a categorical notion of identity, defined using a special object called
Unit (written "I" or "1") and two morphisms λ (left identity) and ρ (right identity); and a categorical notion of associativity defined using a morphism α.

To construct a categorical monoid object, all that we do is take the
basic definitions of an algebraic monoid, and use them to draw a category
diagram.

So, if we have a monoidal category C, then a monoid in the category is
an object M, with two morphisms μ and η. The arrow μ is the
representation of multiplication: it's an arrow μ:M⊗M→M.
η is a morphism called unit which represents identity; it is a
morphism from the monoidal category's identity object to M; η:I→M.
The triple (M,μ,η) is a monoid if and only if the following two
diagrams commute:

With this construction, a monoid object in the category of sets is
exactly an algebraic monoid. So we've come full circle - we've gone
from the algebraic monoid, to the monoidal category, to the categorical monoid, back to the algebraic monoid.

Back when I started to down this categorical path, I said that it helped to understand some of the more complex ideas in abstract algebra. Here's one example. Take the category of abelian groups. A monoid within the
category of abelian groups is a ring. The rings second operation, and its properties are precisely the set of properties that are implied by the commuting diagram above. And as you'll see in later posts, we can use that to understand more about rings in terms of categorical definitions and diagrams.

goodmath Thu, 02/28/2008 - 07:28

Tags

Abstract Algebra

category theory

So take the category of endofunctors on $C$ -- functors from $C$ to itself and natural transformations between them. Now we can compose these functors, making this a monoidal category. What's a monoid object in this category?

Be sure to link back to your Haskell coverage.

This is getting fun! On to Monoidal Categories.

goodmath — Mon, 18 Feb 2008 17:34:34 +0000

This is getting fun! On to Monoidal Categories.

In the last post on groups and related stuff, I talked about the algebraic construction of monoids. A monoid is, basically, the algebraic construction of a category - it's based on the same ideas, and has the same properties; just the presentation of it is different.

But you can also see a monoid in categorical terms. It's what we computer scientists would call a bootstrapped definition: we're relying on the fact that we have all of the constructs of category theory, and then using category theory to rebuild its own basic concepts.

The basic idea of the construction is to start pretty much the same way we did algebraically. The difference is that instead of saying "start with a set", we start with a category.

In this post, I'll define a monoidal category, also called a tensor category. A monoidal category is
a category with a functor, where the functor has the basic properties of a monoid. This is something stronger than a basic monoid - but we can define an algebraic monoid using objects in a monoidal category.

A monoidal category is a category C, paired with a bi-functor - that is a two-argument functor ⊗:C×C→C. This is the categorical form of the tensor operation from the algebraic monoid. To make it a monoidal category, we need to take the tensor operation, and define the properties that it needs to have. They're called its coherence conditions, and basically, they're the properties that are needed to make the diagrams that we're going to use commute.

So - the tensor functor is a bifunctor from C×C to C. There is also an object I∈C, which is called the unit object, which is basically the identity element of the monoid. As we would expect from
the algebraic definition, the tensor functor has two basic properties: associativity, and identity.

Associativity is expressed categorically using a natural isomorphism, which we'll name α. For any three object X, Y, and Z, α includes a component α_X,Y,Z (which I'll label α(X,Y,Z) in diagrams, because subscripts in diagrams are a pain!), which is a mapping from (X⊗Y)⊗Z to X⊗(Y⊗Z). The natural isomorphism says, in categorical terms, that the the two objects on either side of its mappings are
equivalent.

The identity property is again expressed via natural isomorphism. The category must include an object I (called the unit), and
two natural isomorphisms, called &lamba; and ρ. For any
arrow X in C, &lamba; and ρ contain components λ_X and ρ_X such that λ_X maps from I⊗X→X, and ρ_X maps from X⊗I to X.

Now, all of the pieces that we need are on the table. All we need to do is explain how they all fit together - what kinds of properties
these pieces need to have for this to - that is, for these definitions to give us a structure that looks like the algebraic notion of monoidal structures, but built in category theory. The properties
are, more or less, exact correspondences with the associativity and identity requirements of the algebraic monoid. But with category theory, we can say it visually. The two diagrams below each describe one of the two properties.

The upper (pentagonal) diagram must commute for all A, B, C, and D. It describes the associativity property. Each arrow in the diagram is a component of the natural isomorphism over
the category, and the diagram describes what it means for the
natural isomorphism to define associativity.

Similarly, the bottom diagram defines identity. The arrows are all components of natural isomorphisms, and they describe the properties that the natural isomorphisms must have in order for them, together with the unit I to define identity.

This is clearly a whole lot more complicated than the algebraic form. What is it doing?

What we've done is create something much more general. Instead of having a simple notion of abstract functions, we've jumped it up; the basic elements are categories. With algebraic monoids, we were basically working with functions from a set S to itself - and looking at how we could take two functions, each from S to S, and end up with a new composed function S to S; and then looking at what kinds of properties we could get from that.

Here we're looking at categories - essentially monoids with bunches of functions - and looking at functors, which map categories to categories. Just like in the algebraic monoid, we mapped values from a set to itself, in the category, we're looking at functors that map from a category to itself. So we're building a structure with monoidal properties in terms of a structure with monoidal properties. That's where the added complexity of this comes from: we've created a monoidal category, which is an object with a lot more interesting and rich structure to it than a simple algebraic monoid. Using this, we can show what a simple monoid looks like in category theory: it's a particular kind of object in a monoidal category. (But that's a subject for another post.)

So what does this mess give us? We've done a lot more work than we did in the algebraic monoid. I've said this gives us something with
more properties. But does that really have any benefit? Does this express anything that we care about beyond what we could do with the simple algebraic monoid?

Yes. I'll talk more about them later, but one example is that
if we've got a commutative ring, then we can define structures over it called modules. The modules over the ring form a monoidal category - which means that we can define them as being a monoid, but more than just a simple monoid - it's a monoid whose
composition operation preserves the structural properties of modules over the ring.

goodmath Mon, 02/18/2008 - 12:34

Tags

Abstract Algebra

category theory

That's λ or rather &lambda, not &lamba;.

The essential thing about monoidal categories is that we've replaced equations (which denote "identity") by isomorphisms. That is, where we wrote two things as being equal -- identical -- we now say they're only equivalent.

This shows up already in the category of sets. If we have three sets A, B, and C, we can make the product (AxB)xC and the product Ax(BxC). The elements of the first product are triples that look like ((a,b),c), and those of the second are triples that look like (a,(b,c)). Notice that these are not the same thing, and so the two products don't give the same set! But there's a natural isomorphism (AxB)xC -> Ax(BxC), so the sets are equivalent, even if they aren't identical.

And what happens if we take cardinalities of these sets? We identify sets (or objects in general) which were only isomorphic before! That is, our associator isomorphism for cartesian products becomes an associativity equation for natural number multiplication!

John:

Thanks! I tried to get that across in my writing, but I don't think I did a great job; your comment clarifies the isomorphism idea beautifully.

Mark, I just wanted to say that I really enjoy your blog and your posts! They are really good, especially when you analyze and comment fallacies among many, creationists, are doing.

Since you are well versed in mathematics, logic, computer science and such, would you mind analyzing the CTMU by Chistopher Langan? Since this guy is supposed to have really high IQ (whatever that means) and additionally developed a theory of everything (TOE) that is heavily built on scientific/mathematical/logical jargon and thought processes that I believe you are able to understand to a certain high degree.

Here is a link for starters: http://megafoundation.org/CTMU/Articles/IntroCTMU.htm

Thanks again for your blog Mark!

Abstract Algebra and Computation - Monoids

goodmath — Sun, 10 Feb 2008 20:28:08 +0000

Abstract Algebra and Computation - Monoids

In the last couple of posts, I showed how we can start looking at group
theory from a categorical perspective. The categorical approach gives us a
different view of symmetry that we get from the traditional algebraic
approach: in category theory, we see symmetry from the viewpoint of
groupoids - where a group, the exemplar of symmetry, is seen as an
expression of the symmetries of a simpler structure.

We can see similar things as we climb up the stack of abstract algebraic
constructions. If we start looking for the next step up in algebraic
constructions, the rings, we can see a very different view of
what a ring is.

Before we can understand the categorical construction of rings, we need
to take a look at some simpler constructions. Rings are expressed in
categories via monoids. Monoids are wonderful things in their own right, not
just as a stepping stone to rings in abstract algebra.

What makes them so interesting? Well, first, they're a solid bridge
between the categorical and algebraic views of things. We saw how the
category theoretic construction of groupoids put group theory on a nice
footing in category theory. Monoids can do the same in the other direction:
they're in some sense the abstract algebraic equivalent of categories.
Beyond that, monoids actually have down-to-earth practical applications -
you can use monoids to describe computation, and in fact, many of the
fundamental automatons that we use in computer science are, semantically,
monoids.

Let's start with the algebraic view - we'll look at that, and then we'll
shift gears and see how it looks categorically. In terms of abstract
algebra, a monoid is an algebraic structure which captures the basic idea of
function composition. That should be ringing some bells - the
fundamental concept of category theory is an abstract view of function
composition!

A monoid is, like a group, a set of values with a single binary
operation. The monoid is a simpler construct though - since all it captures
is the idea of composition, it doesn't need inverses. For a monoid, we say
that it's a set of values, M, and a binary operation º, with three
properties:

Closure: ∀a,m∈M: aºb ∈ M
Identity: ∃ i∈M : ∀f∈M : iºf = fºi = f.
Associativity: ∀ a,b,c∈M: (aºb)ºc = aº(bºc).

That's really it. If you think of those properties in terms of functions
and function composition, they all make really good sense. They're looking
at the most canonical form of functions - so all functions are treated as
being, roughly, functions from natural numbers to natural numbers. Closure
says that if I've got two simple total functions a and b, then composing a
and b is also a simple total function. Identity says that there's a function
f(x)=x which composes properly. And associativity says shifting the order in
which I evaluate compositions doesn't change the resulting composed
function. Those are all very natural properties of function composition.

What happens if we treat a monoid like a group, and try to use it as an
action? The answer is near and dear to the hearts of computer science folks
like me: what you get is basically a finite state machine!

Take a monoid, (M,º). We can define an action of the
monoid on a set S. The action is an operation *:M×S→S - that is,
from a value in M and a value in S to a value in S. This monoid
action of M on S has two properties - which are basically just
extensions of the monoid properties through the action:

Identity: ∀s∈S, i*s=s.
Associativity: ∀a,b∈M, ∀s∈S: a*(b*s) = (aºb)*s.

What's that mean? What we've done is add function application
to the monoid. The monoidal operation is the application of the functions in
M.

So, what do we get if we have a collection of related composable
functions that can be applied to particular set of values?

An automaton - that is, a mathematical model of a computing device.

How's that an automaton?

With the monoidal operator, each member of the monoid is a
function, which maps a values to values. Monoidal composition
chains those functions together. In terms of automata, each member of the
monoid is a step in a computation. Monoidal composition is chaining
the steps of a computation in the automaton together in sequence. It's not
quite full computation yet - but it's a huge step towards it, in an
extremely simple form.

Think about it just a tad more. Remember href="http://scienceblogs.com/goodmath/2006/08/a_lambda_calculus_rerun_1.php">lambda
calculus? Lambda calculus is a tool from logic for describing
computation in terms of nothing but functions. Guess what? We've just
recreated a substantial part of lambda calculus coming at it from the
direction of abstract algebra.

I'll have more to say about that in future posts - but first I'll need
to show you what this all looks like in terms of category theory - because
the next big step is clearest in category land.

goodmath Sun, 02/10/2008 - 15:28

Tags

Abstract Algebra