# User:Michiexile/MATH198/Lecture 7

(Difference between revisions)
 Revision as of 21:13, 2 November 2009 (edit)← Previous diff Current revision (19:16, 4 November 2009) (edit) (undo) (7 intermediate revisions not shown.) Line 1: Line 1: - IMPORTANT NOTE: THESE NOTES ARE STILL UNDER DEVELOPMENT. PLEASE WAIT UNTIL AFTER THE LECTURE WITH HANDING ANYTHING IN, OR TREATING THE NOTES AS READY TO READ. - Last week we saw what an adjunction was. Here's one thing we can do Last week we saw what an adjunction was. Here's one thing we can do with adjunctions. with adjunctions. Line 6: Line 4: Now, let $U$ be a left adjoint to $F$. We set $T = UF$. Then we have natural transformations Now, let $U$ be a left adjoint to $F$. We set $T = UF$. Then we have natural transformations - $\mu: UFUF -> UF$ + :$\mu: UFUF -> UF$ - $\mu_X = U \epsilon_{FX}$ + :$\mu_X = U \epsilon_{FX}$ - $\iota: 1 -> UF$ + :$\iota: 1 -> UF$ - $\iota_X = \eta_X$ + :$\iota_X = \eta_X$ such that $\mu$ is associative and $\iota$ is the unit of $\mu$. such that $\mu$ is associative and $\iota$ is the unit of $\mu$. Line 18: Line 16: ===Algebraic objects in categories=== ===Algebraic objects in categories=== - \$THEORY objects in Categories. + We recall the definition of a monoid: - Now, we call something a monad in a category if it is a monoid object + '''Definition''' A ''monoid'' is a set $M$ equipped with an operation $\mu: M\times M\to M$ that we call ''composition'' and an operation $e: 1\to M$ that we call the identity, such that - in the category of endofunctors of that category. + * $M \circ 1_M \times M = M \circ M \times 1_M$ (associativity) + * $M \circ 1_M \times e = M \circ e\times 1_M = 1_M$ (unity) + + If we have a ''monoidal category'' - a category $C$ with a bifunctor $\otimes: C\times C\to C$ called the ''tensor product'' which is associative (up to natural isomorphisms) and has an object $I$ acting as a unit (up to natural isomorphisms) for the tensor product. + + The product in a category certainly works as a tensor product, with a terminal object acting as a unit. However, there is often reason to have a non-commutative tensor product for the monoidal structure of a category. This makes the category a ''cartesian monoidal category''. + + For, say, abelian groups, or for vector spaces, we have the ''tensor product'' forming a non-cartesian monoidal category structure. And it is important that we do. + + And for the category of endofunctors on a category, we have a monoidal structure induced by composition of endofunctors: $F\otimes G = F\circ G$. The unit is the identity functor. + + Now, we can move the definition of a monoid out of the category of sets, and define a generic ''monoid object'' in a monoidal category: + + '''Definition''' A ''monoid object'' in a monoidal category $C$ is an object $M$ equipped with morphisms $\mu: M\otimes M\to M$ and $e: 1\to M$ such that + * $M \circ 1_M \otimes M = M \circ M\otimes 1_M$ (associativity) + * $M \circ 1_M \otimes e = M \circ e\otimes 1_M = 1_M$ (unity) + + As an example, a monoid object in the cartesian monoidal category $Set$ is just a monoid. A monoid object in the category of abelian groups is a ring. + + A monoid object in the category of abelian groups, with the tensor product for the monoidal structure is a ''ring''. + + And the composition $UF$ for an adjoint pair is a monoid object in the category of endofunctors on the category. + + The same kind of construction can be made translating familiar algebraic definitions into categorical constructions with many different groups of definitions. For ''groups'', the corresponding definition introduces a diagonal map $\Delta: G\to G\times G$, and an inversion map $i: M\to M$ to codify the entire definition. + + One framework that formalizes the whole thing, in such a way that the definitions themselves form a category is the theory of Sketches by Charles Wells. In one formulation we get the following definition: + + '''Definition''' A ''sketch'' $S = (G, D, L, K)$ consists of a graph $G$, a set of diagrams $D$, a set $L$ of cones in $G$ and a set $K$ of cocones in $G$. + + A ''model'' of a sketch ''S'' in a category $C$ is a graph homomorphism $G\to C$ such that the image of each diagram in $D$ is commutative, each of the cones is a limit cone and each of the cocones is a colimit cocone. + + A ''homomorphism of models'' is just a natural transformation between the models. ---- ---- - We thus define a ''monad in a category $C$'' to be a monoid in that category. + We thus define a ''monad in a category $C$'' to be a monoid object in the category of endofunctors on that category. + + Specifically, this means: + + '''Definition''' A ''monad'' in a category $C$ is an endofunctor $T: C\to C$ equipped with natural transformations $\mu: T^2\to T$ and $\eta: 1\to T$ such that the following diagrams commute: + + [[Image:MonadAssociative.png]] + [[Image:MonadUnit.png]] - Thus: a monad with this definition in Haskell is: + We can take this definition and write it out in Haskell code, as: - * a type of kind m :: * -> *. + - * equipped with functions + - ** return :: a -> m a + - ** join :: m m a -> m a + - * examples: + - List: + class Functor m => MathematicalMonad m where - return x = [x] + return :: a -> m a - join (l:lsts) = l ++ join lsts + join :: m (m a) -> m a - Maybe: + -- such that - return x = Just x + join . fmap return = id :: m a -> m a - join (Just (Just x)) = Just x + join . return = id :: m a -> m a - join _ = Nothing + join . join = join . fmap join :: m (m (m a)) -> m a - Note: not quite what Haskell claims a monad to be. Other related + Those of you used to Haskell will notice that this is not the same as the Monad typeclass. That type class calls for a natural transformation (>>=) :: m a -> (a -> m b) -> m b (or bind). - concepts: + - * Kleisli category & factorization of monads: if we start with T a + The secret of the connection between the two lies in the Kleisli category, and a way to build adjunctions out of monads as well as monads out of adjunctions. - monad, then can we find an adjunction U -| F to _somewhere_ such + - that T = UF? And the monoidal structure is given by U e_FX and + - eta_X? + - * From the Kleisli Category to monadic bind. + ===Kleisli category=== - * Monads and sequencing. + We know that an adjoint pair will give us a monad. But what about getting an adjoint pair out of a monad? Can we reverse the process that got us the monad in the first place? + There are several different ways to do this. Awodey uses the ''Eilenberg-Moore category'' which has as objects the ''algebras of the monad $T$'': morphisms $h: Tx \to x$. A morphism $f: (\alpha: TA\to A)\to (\beta: TB\to B)$ is just some morphism $f:A\to B$ in the category $C$ such that $f\circ\alpha = \beta\circ T(f)$. + We require of $T$-algebras two additional conditions: + * $1_A = h\circ\eta_A$ (unity) + * $h\circ\mu_A = h \circ Th$ (associativity) + There is a forgetful functor that takes some $h$ to $t(h)$, picking up the object of the $T$-algebra. Thus $U(h:TA\to A) = A$, and $U(f) = f$. + We shall construct a left adjoint $F$ to this from the data of the monad $T$ by setting $FC = (\mu_C: T^2C\to TC)$, making $TC$ the corresponding object. And plugging the corresponding data into the equations, we get: + * $1_{TC} = \mu_C\circ\eta_{TC}$ + * $\mu_C\circ\mu_{TC} = \mu_C\circ T\mu_C$ + which we recognize as the axioms of unity and associativity for the monad. + [[Image:MonadAssociative.png]] + [[Image:MonadUnit.png]] + By working through the details of proving this to be an adjunction, and examining the resulting composition, it becomes clear that this is in fact the original monad $T$. However - while the Eilenberg-Moore construction is highly enlightening for constructing formal systems for algebraic theories, and even for the fixpoint definitions of data types, it is less enlightening to understand Haskell's monad definition. + To get to terms with the Haskell approach, we instead look to a different construction aiming to fulfill the same aim: the ''Kleisli category'': + Given a monad $T$ over a category $C$, equipped with unit $\eta$ and concatenation $\mu$, we shall construct a new category $K(T)$, and an adjoint pair of functors $U,F$ factorizing the monad into $T=UF$. + We first define $K(T)_0 = C_0$, keeping the objects from the original category. + Then, we set $K(T)_1$ to be the collection of arrows, in $C$, on the form $A\to TB$. + The composition of $f: A\to TB$ with $g: B\to TC$ is given by the sequence + $A\to^f TB\to^{Tg} T^2C\to^{\mu_C} TC$ + The identity is the arrow $\eta_A: A\to TA$. The identity property follows directly from the unity axiom for the monad, since $\eta_A$ composing with $\mu_A$ is the identity. + Given this category, we next define the functors: + * $U(A) = TA$ + * $U(f: A\to TB) = TA\to^{Tf} T^2B\to^{\mu_B} TB$ + * $F(A) = A$ + * $F(g: A\to B) = A\to^{\eta_A} TA\to^{Tg} TB$ + This definition makes $U, F$ an adjoint pair. Furthermore, we get + * $UF(A) = U(A) = TA$ + * $UF(g: A\to B) = U(Tg\circ\eta_A) = \mu_B\circ T(Tg\circ\eta_A)$ + : $=\mu_B\circ T^2g \circ T\eta_A$, and by naturality of $\mu$, we can rewrite this as + : $=Tg \circ \mu_A\circ T\eta_A = Tg\circ 1_{TA} = Tg$ by unitality of $\eta$. + We've really just chased through this commutative diagram: + :[[Image:KleisliFactorizationDiagram.png]] + Hence, the composite $UF$ really is just the original monad functor $T$. + But what's the big deal with this? you may ask. The big deal is that we now have a monad specification with a different signature. Indeed, the Kleisli arrow for an arrow f :: a -> b and a monad Monad m is something on the shape fk :: a -> m b. And the Kleisli factorization tells us that the Haskell monad specification and the Haskell monad laws are equivalent to their categorical counterparts. + And the composition of Kleisli arrows is easy to write in Haskell: + + f :: a -> m b + g :: b -> m c + (>>=) :: m a -> (a -> m b) -> m b -- Monadic bind, the Haskell definition + kleisliCompose f g :: a -> m c + kleisliCompose f g = (>>= g) . f + - ===Some adjunctions we already know=== + ===Examples=== - * initial/terminal are adjunctions. + Some monads in Haskell are: - * (co)-products are adjunctions. + - * Actually, all (co)limits are adjunctions. + + ====The List monad==== + Lists form a monad, with the following (redundant) definition: + + instance Monad [] where + return x = [x] - ===Some adjunctions we don't know yet=== + [] >>= _ = [] + (x:xs) >>= f = f x : xs >>= f - * Existential and universal qualifiers as adjunctions. + join [] = [] - * Powersets and im(f) -| f^\inv + join (l:ls) = l ++ join ls + - ===Properties of adjoints=== + As it turns out, the lists monad can be found by considering the free and forgetful functors between sets and monoids. Indeed, the lists are what we get from the Kleene star operation, which is the monad we acquire by composing the free monoid functor with the forgetful functor. + + ====Error handling==== + + We can put a monadic structure on a coproduct $A+B$ so that the monadic bind operation performs computations $A+B\to A'+B$ until some computation fails, returning an error, typed $B$, after which we bypass any further computations, just carrying the error out of the entire computation. + + The endofunctor here is $+B$. So the monad is given from a way to go from $A+B+B\to A+B$. Doing this is easy: in Haskell terms, we just remove the constructor differences between the two copies of $B$ floating around. Mathematically, this is just using the functoriality of the coproduct construction on the inclusion maps into $A+B$. + + For our example, we shall return the first value of $B$ to ever occur, thus making our join operator look like this: + + join :: (Either b (Either b a)) -> Either b a + join (Left y) = Left y + join (Right (Left y)) = Left y + join (Right (Right x)) = Right x + + + This gives us a Haskell monad defined by: + + instance Monad (Either b) where + return x = Right x + + Left y >>= _ = Left y + Right x >>= f = f x + - ====RAPL: Right Adjoints Preserve Limits==== - ====Recognizing adjoints==== + ===Additional reading=== - '''Theorem''' (Freyd: The Adjoint Functor Theorem) + * http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html (one of the least dramatic monads tutorials out there) + * http://www.disi.unige.it/person/MoggiE/ftp/lc88.ps.gz (Moggi: ''Computational lambda-calculus and monads'', one of the papers that started the interest in monads. Logic, dense reading.) + * http://www.haskell.org/haskellwiki/Research_papers/Monads_and_arrows (good catalogue over further reading on monads) + ===Homework=== - ===Why should we care in CS?=== + Full marks will be given for 4 out of the 7 questions. - ====Monads==== + # Prove that the Kleisli category adjunction is an adjunction. + # Prove that the Eilenberg-Moore category adjunction is an adjunction. + # Given monad structures on $S$ and $T$, + # The ''writer'' monad W is defined by + #* data Monoid m => W m x = W (x, m) + #* fmap f (W (x, m)) = W (f x, m) + #* return x = W (x, mempty) + #* join (W (W (x, m), n)) = W (x, m mappend n) + ## (2pt) Prove that this yields a monad. + ## (2pt) Give the Kleisli factorization of the writer monad. + ## (2pt) Give the Eilenberg-Moore factorization of the writer monad. + ## (2pt) Is there a nice, 'natural' adjunction factorizing the writer monad?

## Current revision

Last week we saw what an adjunction was. Here's one thing we can do with adjunctions.

Now, let U be a left adjoint to F. We set T = UF. Then we have natural transformations

μ:UFUF − > UF
μX = UεFX
ι:1 − > UF
ιX = ηX

such that μ is associative and ι is the unit of μ.

These requirements remind us of the definition of a monoid - and this is not that much of a surprise. To see the exact connection, and to garner a wider spread of definitions.

## Contents

### 1 Algebraic objects in categories

We recall the definition of a monoid:

Definition A monoid is a set M equipped with an operation $\mu: M\times M\to M$ that we call composition and an operation $e: 1\to M$ that we call the identity, such that

• $M \circ 1_M \times M = M \circ M \times 1_M$ (associativity)
• $M \circ 1_M \times e = M \circ e\times 1_M = 1_M$ (unity)

If we have a monoidal category - a category C with a bifunctor $\otimes: C\times C\to C$ called the tensor product which is associative (up to natural isomorphisms) and has an object I acting as a unit (up to natural isomorphisms) for the tensor product.

The product in a category certainly works as a tensor product, with a terminal object acting as a unit. However, there is often reason to have a non-commutative tensor product for the monoidal structure of a category. This makes the category a cartesian monoidal category.

For, say, abelian groups, or for vector spaces, we have the tensor product forming a non-cartesian monoidal category structure. And it is important that we do.

And for the category of endofunctors on a category, we have a monoidal structure induced by composition of endofunctors: $F\otimes G = F\circ G$. The unit is the identity functor.

Now, we can move the definition of a monoid out of the category of sets, and define a generic monoid object in a monoidal category:

Definition A monoid object in a monoidal category C is an object M equipped with morphisms $\mu: M\otimes M\to M$ and $e: 1\to M$ such that

• $M \circ 1_M \otimes M = M \circ M\otimes 1_M$ (associativity)
• $M \circ 1_M \otimes e = M \circ e\otimes 1_M = 1_M$ (unity)

As an example, a monoid object in the cartesian monoidal category Set is just a monoid. A monoid object in the category of abelian groups is a ring.

A monoid object in the category of abelian groups, with the tensor product for the monoidal structure is a ring.

And the composition UF for an adjoint pair is a monoid object in the category of endofunctors on the category.

The same kind of construction can be made translating familiar algebraic definitions into categorical constructions with many different groups of definitions. For groups, the corresponding definition introduces a diagonal map $\Delta: G\to G\times G$, and an inversion map $i: M\to M$ to codify the entire definition.

One framework that formalizes the whole thing, in such a way that the definitions themselves form a category is the theory of Sketches by Charles Wells. In one formulation we get the following definition:

Definition A sketch S = (G,D,L,K) consists of a graph G, a set of diagrams D, a set L of cones in G and a set K of cocones in G.

A model of a sketch S in a category C is a graph homomorphism $G\to C$ such that the image of each diagram in D is commutative, each of the cones is a limit cone and each of the cocones is a colimit cocone.

A homomorphism of models is just a natural transformation between the models.

We thus define a monad in a category C to be a monoid object in the category of endofunctors on that category.

Specifically, this means:

Definition A monad in a category C is an endofunctor $T: C\to C$ equipped with natural transformations $\mu: T^2\to T$ and $\eta: 1\to T$ such that the following diagrams commute:

We can take this definition and write it out in Haskell code, as:

class Functor m => MathematicalMonad m where
return :: a -> m a
join   :: m (m a) -> m a

-- such that
join . fmap return = id               :: m a -> m a
join . return      = id               :: m a -> m a
join . join        = join . fmap join :: m (m (m a)) -> m a
Those of you used to Haskell will notice that this is not the same as the
typeclass. That type class calls for a natural transformation
(>>=) :: m a -> (a -> m b) -> m b
(or
bind
).

The secret of the connection between the two lies in the Kleisli category, and a way to build adjunctions out of monads as well as monads out of adjunctions.

### 2 Kleisli category

We know that an adjoint pair will give us a monad. But what about getting an adjoint pair out of a monad? Can we reverse the process that got us the monad in the first place?

There are several different ways to do this. Awodey uses the Eilenberg-Moore category which has as objects the algebras of the monad T: morphisms $h: Tx \to x$. A morphism $f: (\alpha: TA\to A)\to (\beta: TB\to B)$ is just some morphism $f:A\to B$ in the category C such that $f\circ\alpha = \beta\circ T(f)$.

We require of T-algebras two additional conditions:

• $1_A = h\circ\eta_A$ (unity)
• $h\circ\mu_A = h \circ Th$ (associativity)

There is a forgetful functor that takes some h to t(h), picking up the object of the T-algebra. Thus $U(h:TA\to A) = A$, and U(f) = f.

We shall construct a left adjoint F to this from the data of the monad T by setting $FC = (\mu_C: T^2C\to TC)$, making TC the corresponding object. And plugging the corresponding data into the equations, we get:

• $1_{TC} = \mu_C\circ\eta_{TC}$
• $\mu_C\circ\mu_{TC} = \mu_C\circ T\mu_C$

which we recognize as the axioms of unity and associativity for the monad.

By working through the details of proving this to be an adjunction, and examining the resulting composition, it becomes clear that this is in fact the original monad T. However - while the Eilenberg-Moore construction is highly enlightening for constructing formal systems for algebraic theories, and even for the fixpoint definitions of data types, it is less enlightening to understand Haskell's monad definition.

To get to terms with the Haskell approach, we instead look to a different construction aiming to fulfill the same aim: the Kleisli category:

Given a monad T over a category C, equipped with unit η and concatenation μ, we shall construct a new category K(T), and an adjoint pair of functors U,F factorizing the monad into T = UF.

We first define K(T)0 = C0, keeping the objects from the original category.

Then, we set K(T)1 to be the collection of arrows, in C, on the form $A\to TB$.

The composition of $f: A\to TB$ with $g: B\to TC$ is given by the sequence $A\to^f TB\to^{Tg} T^2C\to^{\mu_C} TC$

The identity is the arrow $\eta_A: A\to TA$. The identity property follows directly from the unity axiom for the monad, since ηA composing with μA is the identity.

Given this category, we next define the functors:

• U(A) = TA
• $U(f: A\to TB) = TA\to^{Tf} T^2B\to^{\mu_B} TB$
• F(A) = A
• $F(g: A\to B) = A\to^{\eta_A} TA\to^{Tg} TB$

This definition makes U,F an adjoint pair. Furthermore, we get

• UF(A) = U(A) = TA
• $UF(g: A\to B) = U(Tg\circ\eta_A) = \mu_B\circ T(Tg\circ\eta_A)$
$=\mu_B\circ T^2g \circ T\eta_A$, and by naturality of μ, we can rewrite this as
$=Tg \circ \mu_A\circ T\eta_A = Tg\circ 1_{TA} = Tg$ by unitality of η.

We've really just chased through this commutative diagram:

Hence, the composite UF really is just the original monad functor T.

But what's the big deal with this? you may ask. The big deal is that we now have a monad specification with a different signature. Indeed, the Kleisli arrow for an arrow
f :: a -> b
is something on the shape
fk :: a -> m b
. And the Kleisli factorization tells us that the Haskell monad specification and the Haskell monad laws are equivalent to their categorical counterparts.

And the composition of Kleisli arrows is easy to write in Haskell:

f :: a -> m b
g :: b -> m c

(>>=) :: m a -> (a -> m b) -> m b -- Monadic bind, the Haskell definition

kleisliCompose f g :: a -> m c
kleisliCompose f g = (>>= g) . f

### 3 Examples

Lists form a monad, with the following (redundant) definition:

instance Monad [] where
return x     = [x]

[] >>= _     = []
(x:xs) >>= f = f x : xs >>= f

join [] = []
join (l:ls) = l ++ join ls

As it turns out, the lists monad can be found by considering the free and forgetful functors between sets and monoids. Indeed, the lists are what we get from the Kleene star operation, which is the monad we acquire by composing the free monoid functor with the forgetful functor.

#### 3.2 Error handling

We can put a monadic structure on a coproduct A + B so that the monadic bind operation performs computations $A+B\to A'+B$ until some computation fails, returning an error, typed B, after which we bypass any further computations, just carrying the error out of the entire computation.

The endofunctor here is + B. So the monad is given from a way to go from $A+B+B\to A+B$. Doing this is easy: in Haskell terms, we just remove the constructor differences between the two copies of B floating around. Mathematically, this is just using the functoriality of the coproduct construction on the inclusion maps into A + B.

For our example, we shall return the first value of B to ever occur, thus making our join operator look like this:

join :: (Either b (Either b a)) -> Either b a
join (Left y) = Left y
join (Right (Left y)) = Left y
join (Right (Right x)) = Right x

instance Monad (Either b) where
return x = Right x

Left y  >>= _ = Left y
Right x >>= f = f x

### 5 Homework

Full marks will be given for 4 out of the 7 questions.

3. Given monad structures on S and T,
• join (W (W (x, m), n)) = W (x, m mappend n)