User:Michiexile/MATH198/Lecture 4
From HaskellWiki
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.
Contents |
1 Product
Recall the construction of a cartesian product of two sets: . We have functions and extracting the two sets from the product, and we can take any two functions and and take them together to form a function .
Similarly, we can form the type of pairs of Haskell types:An element of the pair is completely determined by the two elements included in it. Hence, if we have a pair of generalized elements and , we can find a unique generalized element such that the projection arrows on this gives us the original elements back.
This argument indicates to us a possible definition that avoids talking about elements in sets in the first place, and we are lead to the
Definition A product of two objects A,B in a category C is an object equipped with arrows such that for any other object V with arrows , there is a unique arrow such that the diagram
commutes. The diagram is called a product cone if it is a diagram of a product with the projection arrows from its definition.
In the category of sets, the unique map is given by q(v) = (q_{1}(v),q_{2}(v)). In the Haskell category, it is given by the combinatorWe tend to talk about the product. The justification for this lies in the first interesting
Proposition If P and P' are both products for A,B, then they are isomorphic.
Proof Consider the diagram
Both vertical arrows are given by the product property of the two product cones involved. Their compositions are endo-arrows of P,P', such that in each case, we get a diagram like
with (or P'), and q_{1} = p_{1},q_{2} = p_{2}. There is, by the product property, only one endoarrow that can make the diagram work - but both the composition of the two arrows, and the identity arrow itself, make the diagram commute. Therefore, the composition has to be the identity. QED.
We can expand the binary product to higher order products easily - instead of pairs of arrows, we have families of arrows, and all the diagrams carry over to the larger case.
1.1 Binary functions
Functions into a product help define the product in the first place, and function as elements of the product. Functions from a product, on the other hand, allow us to put a formalism around the idea of functions of several variables.
So a function of two variables, of types2 Coproduct
The product came, in part, out of considering the pair construction. One alternative way to write thedata Pair a b = Pair a b
and the resulting type is isomorphic, in Hask, to the product type we discussed above.
This is one of two basic things we can do in aThe other thing we can do is to form a union type, by something like
data Union a b = Left a | Right b
This type guarantees the existence of two functions
Left :: a -> Union a b Right :: b -> Union a b
Similarly, in the category of sets we have the disjoint union , which also comes with functions .
We can use all this to mimic the product definition. The directions of the inclusions indicate that we may well want the dualization of the definition. Thus we define:
Definition A coproduct A + B of objects A,B in a category C is an object equipped with arrows such that for any other object V with arrows , there is a unique arrow such that the diagram
commutes. The diagram is called a coproduct cocone, and the arrows are inclusion arrows.
For sets, we need to insist that instead of just any and , we need the specific construction taking pairs for the coproduct to work out well. The issue here is that the categorical product is not defined as one single construction, but rather from how it behaves with respect to the arrows involved.
With this caveat, however, the coproduct in Set really is the disjoint union sketched above.
For Hask, the coproduct is the type construction ofAnd following closely in the dualization of the things we did for products, there is a first
Proposition If C,C' are both coproducts for some pair A,B in a category D, then they are isomorphic.
The proof follows the exact pattern of the corresponding proposition for products.
3 Cartesian Closed Categories and typed lambda-calculus
A category is said to have pairwise products if for any objects A,B, there is a product object .
A category is said to have pairwise coproducts if for any objects A,B, there is a coproduct object A + B.
Recall when we talked about internal homs in Lecture 2. We can now define what we mean, formally, by the concept:
Definition An object C in a category D is an internal hom object or an exponential object or B^{A} if it comes equipped with an arrow , called the evaluation arrow, such that for any other arrow , there is a unique arrow such that the composite
is f.
The idea here is that with something in an exponential object, and something in the source of the arrows we imagine live inside the exponential, we can produce the evaluation of the arrow at the source to produce something in the target. Using global elements, this reasoning comes through in a more natural manner: given and we can produce the global element . Furthermore, we can always produce something in the exponential whenever we have something that looks as if it should be there.
And with this we can define
Definition A category C is a Cartesian Closed Category or a CCC if:
- C has a terminal object 1
- Each pair of objects has a product and projections , .
- For every pair of objects, there is an exponential object with an evaluation map .
3.1 Currying
Note that the exponential as described here is exactly what we need in order to discuss the Haskell concept of multi-parameter functions. If we consider the type of a binary function in Haskell:
binFunction :: a -> a -> a
On the other hand, we can feed in both values at once, and get
binFunction' :: (a,a) -> a
which lives in the exponential object .
These are genuinely different objects, but they seem to do the same thing: consume two distinct values to produce a third value. The resolution of the difference lies, again, in a recognition from Set theory: there is an isomorphism
which we can use as inspiration for an isomorphism valid in Cartesian Closed Categories.
As it turns out, this is exactly what we need for Failed to parse (unknown function\lamdba): \lamdba -calculus. Any typed Failed to parse (unknown function\lamdba): \lamdba -calculus gives rise to a CCC in a natural manner, and any CCC has an internal language which satisfies, by the axioms for the CCC, all requirements to be a typed Failed to parse (unknown function\lamdba): \lamdba -calculus.
More importantly, by stating Failed to parse (unknown function\lamdba): \lamdba -calculus in terms of a CCC instead of in terms of terms and rewriting rules is that you can escape worrying about variable clashes, alpha reductions and composability - the categorical translation ignores, at least superficially, the variables, reduces terms with morphisms that have equality built in, and provides associative composition for free.
At this point, I'd reccomend reading more on Wikipedia [1] and [2], as well as in Lambek & Scott: Introduction to Higher Order Categorical Logic. The book by Lambek & Scott goes into great depth on these issues, but may be less than friendly to a novice.
4 Algebra of datatypes
Recall from Lecture 3 that we can consider endofunctors as container datatypes. Some of the more obvious such container datatypes include:
data 1 a = Empty data T a = T a
These being the data type that has only one single element and the data type that has exactly one value contained.
Using these, we can generate a whole slew of further datatypes. First off, we can generate a data type with any finite number of elements by (n times). Remember that the coproduct construction for data types allows us to know which summand of the coproduct a given part is in, so the single elements in all theFurthermore, we can note that , with the isomorphism given by the maps
f (Empty, T x) = T x g (T x) = (Empty, T x)
Thus we have the capacity to add and multiply types with each other. We can verify, for any types A,B,C
We can thus make sense of types like T^{3} + 2T^{2} (either a triple of single values, or one out of two tagged pairs of single values).
This allows us to start working out a calculus of data types with versatile expression power. We can produce recursive data type definitions by using equations to define data types, that then allow a direct translation back into Haskell data type definitions, such as:
The real power of this way of rewriting types comes in the recognition that we can use algebraic methods to reason about our data types. For instance:
List = 1 + T * List = 1 + T * (1 + T * List) = 1 + T * 1 + T * T* List = 1 + T + T * T * List
so a list is either empty, contains one element, or contains at least two elements. Using, though, ideas from the theory of power series, or from continued fractions, we can start analyzing the data types using steps on the way that seem completely bizarre, but arriving at important property. Again, an easy example for illustration:
List = 1 + T * List -- and thus List - T * List = 1 -- even though (-) doesn't make sense for data types (1 - T) * List = 1 -- still ignoring that (-)... List = 1 / (1 - T) -- even though (/) doesn't make sense for data types = 1 + T + T*T + T*T*T + ... -- by the geometric series identity
and hence, we can conclude - using formally algebraic steps in between - that a list by the given definition consists of either an empty list, a single value, a pair of values, three values, et.c.
At this point, I'd recommend anyone interested in more perspectives on this approach to data types, and thinks one may do with them, to read the following references:
4.1 Blog posts
4.2 Research papers
d for data types 7 trees into 1
5 Homework
- What are the products in the category C(P) of a poset P? What are the coproducts?
- Prove that any two coproducts are isomorphic.
- Prove that any two exponentials are isomorphic.
- Prove that currying/uncurrying are isomorphisms in a CCC. Hint: the map is a map .
- Write down the type declaration for at least two of the example data types from the section of the algebra of datatypes, and write a implementation for each.Functor