# Category theory/Natural transformation

### From HaskellWiki

EndreyMark (Talk | contribs) (Categorizing under Category:Theoretical foundations) |
EndreyMark (Talk | contribs) (New sections:/*Operations*/, beginning with - →Functor and natural transformation: : example: fmapping parser on optional data to parser on listed data) |
||

Line 138: | Line 138: | ||

* Words “side”, “horizontal”, “vertical”, “left”, “right” serve here only to point to the discussed parts of a diagram, thus, they are not part of the scientific terminology. |
* Words “side”, “horizontal”, “vertical”, “left”, “right” serve here only to point to the discussed parts of a diagram, thus, they are not part of the scientific terminology. |
||

* If You want to modifiy the [[#Commutative diagram]], see its [[Media:Natural_transformation.tex|source code]] (in LaTeX using <code>amscd</code>). |
* If You want to modifiy the [[#Commutative diagram]], see its [[Media:Natural_transformation.tex|source code]] (in LaTeX using <code>amscd</code>). |
||

+ | |||

+ | == Operations == |
||

+ | |||

+ | === Functor and natural transformation === |
||

+ | |||

+ | Let us imagine a parser library, which contains functions for parsing a form. There are two kinds of cells: |
||

+ | * containing data which are optional (e.g. name of spouse) |
||

+ | * containing data which consist of an enumaration of items (e.g. names of acquired languages) |
||

+ | |||

+ | <haskell> |
||

+ | languages :: Parser [String] |
||

+ | spouse :: Parser String |
||

+ | </haskell> |
||

+ | |||

+ | Let us imagine we have any processing (storing, archiving etc.) function which processes lists (or any other reason which forces us to convert our results tu list fomrat instead of lists). (Maybe all this example is unparactical and exaggerated!) |
||

+ | |||

+ | We can convert <hask>Maybe</hask> to list with <hask>maybeToList</hask> |
||

+ | But if we want to do something similar with a ''parser'' on Maybe's to achieve a ''parser'' on list, then <hask>maybeToList</hask> is not enough alone, we must <hask>fmap</hask> it. |
||

+ | E.g. if we want to convert a parser like <hask>spouse</hask> to be of the same type as <hask>languages</hask>: |
||

+ | <haskell> |
||

+ | fmap maybeToList spouse |
||

+ | </haskell> |
||

+ | Let us see the types: |
||

+ | We start with |
||

+ | <haskell> |
||

+ | spouse :: Parser (Maybe String) |
||

+ | </haskell> |
||

+ | :<math>\Lambda(\Phi(X))</math> |
||

+ | or using notion of composing functors |
||

+ | :<math>(\Lambda \Phi)(X)</math> |
||

+ | We want to achieve |
||

+ | <haskell> |
||

+ | fmap maybeToList spouse :: Parser [String] |
||

+ | </haskell> |
||

+ | :<math>\Lambda(\Psi(X))</math> |
||

+ | :<math>(\Lambda \Psi)(X)</math> |
||

+ | thus we can infer |
||

+ | <haskell> |
||

+ | fmap maybeToList :: Parser (Maybe [String]) -> Parser [String] |
||

+ | </haskell> |
||

+ | :<math>\mathrm{Hom}{(\Lambda\Phi)(X),\;(\Lambda\Psi)(X)}</math> |
||

+ | In fact, we have a new "datatype converter": converting not Maybe's to lists, but parser on Maybe to Parser on list. Let us notate the corresponding natural transformation with <math>\Lambda\eta</math>: |
||

+ | :To each <math>X \in \mathbf{Ob}(\mathcal C)</math> we associate <math>(\Lambda\eta)_X \in \mathrm{Hom}_{\mathcal D}(\Lambda\Phi)(X),\;(\Lambda\Psi)(X))</math> |
||

+ | :<math>\Lambda\eta : \Lambda\Phi \to \Lambda\Psi</math> |
||

+ | :<math>(\Lambda\eta)_X = \Lambda(\eta_X)</math> |
||

+ | <haskell> |
||

+ | </haskell> |
||

+ | |||

+ | <haskell> |
||

+ | </haskell> |
||

=== External links === |
=== External links === |

## Revision as of 09:08, 4 October 2006

## Contents |

## 1 Example: maybeToList

map even $ maybeToList $ Just 5

yields the same as

maybeToList $ fmap even $ Just 5

yields: both yield

[False]

### 1.1 Commutative diagram

- Let , denote categories.
- Let be functors.
- Let . Let .

Let us define the natural transformation. It associates to each object of a morphism of in the following way (usually, not sets are discussed here, but proper classes, so I do not use term “function” for this mapping):

- . We call η
_{A}the component of η at*A*.

Thus, the following diagram commutes (in ):

### 1.2 Vertical arrows: sides of objects

… showing how the natural transformation works.

maybeToList :: Maybe a -> [a]

#### 1.2.1 Left: side of *X* object

maybeToList :: Maybe Int -> [Int] | |

Nothing |
[] |

Just 0 |
[0] |

Just 1 |
[1] |

#### 1.2.2 Right: side of *Y* object

maybeToList :: Maybe Bool -> [Bool] | |

Nothing |
[] |

Just True |
[True] |

Just False |
[False] |

### 1.3 Horizontal arrows: sides of functors

even :: Int -> Bool

#### 1.3.1 Side of Φ functor

fmap even:: Maybe Int -> Maybe Bool | |

Nothing |
Nothing |

Just 0 |
Just True |

Just 1 |
Just False |

#### 1.3.2 Side of Ψ functor

map even:: [Int] -> [Bool] | |

[] |
[] |

[0] |
[True] |

[1] |
[False] |

### 1.4 Commutativity of the diagram

both paths span between

Maybe Int -> [Bool] | ||

map even . maybeToList |
maybeToList . fmap even | |

Nothing |
[] |
[] |

Just 0 |
[True] |
[True] |

Just 1 |
[False] |
[False] |

### 1.5 Remarks

- has a more general type (even) than described hereIntegral a => a -> Bool
- Words “side”, “horizontal”, “vertical”, “left”, “right” serve here only to point to the discussed parts of a diagram, thus, they are not part of the scientific terminology.
- If You want to modifiy the #Commutative diagram, see its source code (in LaTeX using
`amscd`

).

## 2 Operations

### 2.1 Functor and natural transformation

Let us imagine a parser library, which contains functions for parsing a form. There are two kinds of cells:

- containing data which are optional (e.g. name of spouse)
- containing data which consist of an enumaration of items (e.g. names of acquired languages)

languages :: Parser [String] spouse :: Parser String

Let us imagine we have any processing (storing, archiving etc.) function which processes lists (or any other reason which forces us to convert our results tu list fomrat instead of lists). (Maybe all this example is unparactical and exaggerated!)

We can convert*parser*on Maybe's to achieve a

*parser*on list, then

` fmap maybeToList spouse`

Let us see the types: We start with

spouse :: Parser (Maybe String)

- Λ(Φ(
*X*))

or using notion of composing functors

- (ΛΦ)(
*X*)

We want to achieve

fmap maybeToList spouse :: Parser [String]

- Λ(Ψ(
*X*)) - (ΛΨ)(
*X*)

thus we can infer

fmap maybeToList :: Parser (Maybe [String]) -> Parser [String]

In fact, we have a new "datatype converter": converting not Maybe's to lists, but parser on Maybe to Parser on list. Let us notate the corresponding natural transformation with Λη:

- To each we associate
- (Λη)
_{X}= Λ(η_{X})

### 2.2 External links

- The corresponding HaWiki article is not migrated here yet, so You can see it for more information.
- Wikipedia's Natural transformation article