I have to say it took me considerable effort to figure out how to use the part of Haskell’s probability library that deals with randomness and simulation. The intuition developed by programming in imperative languages is especially harmful here.
The paper on which the library is based mentions a function “pick, which selects exactly one value from a distribution by randomly yielding one of the values according to the specified probabilities”. Great, let’s try that out and toss a coin with it.

> :m +Numeric.Probability.Distribution
> :m +Numeric.Probability.Random
> pick $ choose 0.5 0 1

:1:0:
    No instance for (Show (Numeric.Probability.Random.T a))
      arising from a use of `Prelude.print' at :1:0-20
    Possible fix:
      add an instance declaration for
      (Show (Numeric.Probability.Random.T a))
    In the expression: Prelude.print it
    In a 'do' expression: Prelude.print it

A closer analysis of the type signatures reveals that the type of the library function pick is not IO a as in the paper and to get IO from that we need to compose it with run.

> run $ pick $ choose 0.5 0 1
Loading package array-0.1.0.0 ... linking ... done.
Loading package containers-0.1.0.1 ... linking ... done.
Loading package old-locale-1.0.0.0 ... linking ... done.
Loading package old-time-1.0.0.0 ... linking ... done.
Loading package random-1.0.0.0 ... linking ... done.
Loading package mtl-1.1.0.0 ... linking ... done.
Loading package probability-0.2.1 ... linking ... done.
0

This is better, lets try it again.

> run $ pick $ choose 0.5 0 1
0

And again.

> run $ pick $ choose 0.5 0 1
0

What the hell? We keep tossing a coin and get the same result every time! That’s Haskell in its referentially transparent glory.
To get a sample of tossing several coins we need to pick from their joint distribution.

> run $ pick $ replicateM 10 $ choose 0.5 0 1
[0,0,1,1,0,1,0,1,1,0]

Simulation

In my post on Markov chains I defined a transition function on paths for a simple random walk that goes up or down by one with the same probability.

rwstran :: Tran.T Double [Int]
rwstran x = D.choose 0.5 (x ++ [(last x) + 1]) (x ++ [(last x) - 1])

The probability distribution on paths of legth n starting from state v can be calculated as

rws :: Int -> Int -> D.T Double [Int]
rws v n = (Tran.compose $ replicate n rwstran) [v]

This allows for exact calculations of probability of certain events. The basic problem with modeling Markov chains this way is that even for short chains we need lots of the memory to represent the whole sample space.
For the above random walk we can calculate probability that, say, in the first 10 steps we will not go negative, but trying to do the same for 20 steps took longer than I had patience to wait. Haskell’s probability library offers a solution to that: approximating the real distribution with an empirical one obtained from simulation.
I was a bit confused when I first tried to understand this. To simulate a sequence of i.i.d random variables we need to provide the distribution to sample from. But we can’t just repeatedly sample from the same distribution, as we would get the same number all the time. We would have to first create the joint distribution with replicateM. But that defies the purpose, as such distribution would be too large. The answer that the probability library offers is that the simplest objects it models are not sequences of i.i.d random variables, but homogeneous Markov chains. Such Markov chains are determined by the initial value and a function that assigns a probability distribution to each element of the state space (let’s call it a transition funtion). The i.i.d random variables can also be treated as a special case, but the basic setup is tailored for modeling Markov chains.

The most useful tool for simulation is the ~*. operator provided by the Simulation module. It takes a pair of integers as a left side parameter. The first Int is the number of elements in the sample space we want to use. The second one defines the length of the Markov chain we want to simulate. On the right hand side of the operator we put the transition function. So, if we have defined

emprws :: Int -> Int -> IO (T Double [Int])
emprws n k = Rnd.run $ (n,k) ~*. rwstran $ [0]

Then we can get the empirical distribution on paths of the Markov chain of length 20 simulated 10 times as follows:

> emprws 10 20
fromFreqs [([0,-1,-2,-1,-2,-1,-2,-1,0,-1,0,-1,0,-1,-2,-1,-2,-1,-2,-3,-2],0.1),
([0,-1,0,-1,0,-1,-2,-3,-2,-1,0,-1,-2,-3,-2,-1,-2,-1,0,-1,0],0.1),
([0,-1,0,1,0,-1,-2,-1,0,1,2,1,2,3,4,3,2,3,4,5,4],0.1),
([0,1,0,-1,-2,-3,-4,-5,-6,-7,-6,-7,-8,-9,-10,-9,-10,-11,-10,-11,-12],0.1),
([0,1,0,1,0,1,0,-1,-2,-3,-2,-1,0,1,2,1,2,1,2,1,0],0.1),
([0,1,2,1,0,-1,-2,-1,-2,-1,0,-1,-2,-1,-2,-3,-4,-5,-6,-5,-4],0.1),
([0,1,2,1,2,1,0,1,0,-1,0,-1,0,-1,-2,-3,-4,-5,-6,-5,-6],0.1),
([0,1,2,3,2,1,0,-1,-2,-1,-2,-3,-2,-3,-2,-3,-4,-3,-4,-5,-4],0.1),
([0,1,2,3,2,1,2,3,2,1,0,-1,-2,-3,-2,-3,-2,-3,-4,-5,-4],0.1),
([0,1,2,3,2,3,4,3,2,3,4,5,4,5,6,5,6,5,6,5,6],0.1)]

Note that since we use random number generator, the distribution in the result’s type of the simulation is wrapped in the IO monad. Because of that we need to put fmap before using the event probability operator ?? if we want to ask for probability of some event. For example to find out an approximate probability that a random walk of length 20 starting from 0 never goes negative based on simulating the random walk 2000 times we can do

> fmap ((all (>= 0)) ?? ) $ emprws 2000 20
0.17200000000000013

Even more random simulation

The Simulation module defines two instances of the class that the ~*. operator works for. One instance is for distributions as defined in the Distribution module. Such distributions are essentially lists of pairs (value, probability). We describe the Markov chain we want to simulate by defining a function that assigns a distribution of that type to each value of the state space. This works well for Markov chains in which for each state there are only some small number of states where the chain can go next. However consider a Markov chain where the next value is determined by a continuous distribution, for example when , where is a sequence of i.i.d random variables distributed uniformly on the interval . To simulate such Markov chains we can use the second instance of the class defined in the Simulation module. In this second instance we use numbers obtained from a random numbers generator instead of the explicit distribution.

Let’s look at an example. First we define a transition function that describes our Markov chain. We want to model paths of the Markov chain, so the function takes a path (a list of floats) and assigns a (random) path that has one more element, obtained from the random numbers generator.

rwrnd :: Rnd.Change [Float]
rwrnd x = fmap (\delta -> x ++ [(last x) + delta]) $ Rnd.randomR (-1,1)

Such transition function can be used with the ~*. operator in the same way as the rws transition function above.

emprwrnd :: Int -> Int ->  IO (T Double[Float])
emprwrnd n k =  Rnd.run $ (n,k) ~*. rwrnd $ [0]

Now let’s simulate this Markov chain, getting 5 paths of length 10 each:

> emprwrnd 5 10
fromFreqs
[([0.0,-0.87644845,-1.8566498,-1.7820039,-1.9403718,-0.9496375,-1.4706907,
-0.8597232,-1.6741004,-2.1475728,-2.224792],0.2),
([0.0,-0.48623613,-2.408719e-,0.60908824,0.9019042,1.3207725,1.9422557,
1.1668808,0.5517659,1.1509926,1.1245335],0.2),
([0.0,-0.18386137,-1.0592186,-0.95641375,-0.9876149,-1.7923257,-1.4315606,
-1.8640705,-2.6031392,-1.7015955,-1.166816],0.2),
([0.0,2.0809833e-,-0.6174592,-0.41014677,0.42637175,0.4807669,1.0540222,
8.9894295e-2,-0.18835253,0.6476095,0.9155247],0.2),
([0.0,0.97053343,6.692678e-,0.55357254,0.7402272,0.40708384,0.19999743,
-0.37751698,0.5084936,0.303145,0.9905505],0.2)]

We can also ask the same type of questions as we did with with the discrete random walk in a similar way. So, what is the probability that in 20 steps we never go negative?

> fmap ((all (>= 0)) ?? ) $ emprwrnd 2000 20
0.12650000000000008

My new job will involve coding in Q. Q is a scripting language derived from APL. It is mostly used for stuff related to trading and finance. I don’t know it yet, I’m supposed to learn it on the job, so I decided to have a look at it.
As an exercise, I took a couple of Haskell functions in the standard Data.List module and tried to see how one can express them in Q. Experienced Q developers (called “Q gods” in the Q terminology) will probably laugh at my code, but well, I have to start from something. Any corrections and idioms from Q gods are welcome.

Here are a couple of trivial functions that are special cases of builtin Q functions

init: {-1_x} 

tail: {1_x}  

head: {x[0]}

Q is a functional language. It allows to take functions as parameters in functions. Here the takeWhile function takes a predicate as its first parameter. The code is probably too imperative for Q, I am sure there is a better way.

takeWhile:{[p;xs]
           i:0;
           while[(i < count xs) & p[xs[i]]; i+:1];
           xs[til i] / quite readable, isn't it
          }

Q supports anonymous functions so one can call takeWhile as follows:

q) takeWhile [{x>0}; (1;2;4;0;3;4;5)]
1 2 4

Here {x>0} is an anonymous function that returns true (1b) when the argument is positive and 0b when it is less or equal 0.

My first shot at Haskell’s intersperse looked like this:

intersperse: { -1 _ raze y ,' x }

Here y ,' x creates pairs with first element taken from y and second equal to x:

(1;2;3) ,' 0
1 0
2 0
3 0

raze removes one level of nesting so we get a list instead of a list of pairs:

raze (1;2;3) ,' 0
1 0 2 0 3 0

-1 _ then drops the last element

This works well, but only when the first argument is an atom (not list).

intersperse[0;(1;2;3)]
1 0 2 0 3

But when we want to intersperse a list we get an error:

q) intersperse [(0;0);((1;1);(2;2);(3;3))]
{-1 _ raze y ,' x }
'length

To get a more general version we first define Haskell’s replicate:

replicate: {[n;e]
		a: {x, (enlist z)};
		() a[ ; ;e]/ (til n) / folds the dyadic (binary) function a[ ; ;e] over a list of length n
	}

Here a: {x, (enlist z)} creates a triadic (ternary) function that appends the third argument to the first and ignores the second.
This replicate implementation seems too complicated for such simple task, but I was unable to figure out anything simpler.

We also need Haskell’s zip:

zip: { x {(x;y)}' y }

And now we can define intersperse:

intersperse: { -1 _ raze zip [y ; replicate[count y;x]] }

This works better than the first attempt:

q) intersperse [(0;0);((1;1);(2;2);(3;3))]
1 1
0 0
2 2
0 0
3 3

Haskell’s map is kind of redundant in Q as unary functions (called “monadic” in Q, isn’t that funny?) get mapped when called with a list as an argument.

q)(3+)4
7
q) (3+)(1;2;3)
4 5 6
q)

This approach causes problems though when we want to map a function that works both for atoms and lists. One such function is enlist, which creates a singleton list in Q, kind of like Haskell’s return in the list monad.

(enlist 3)[0]
3

So how can we map enlist over a list? Just calling it on a list gives a singleton list with the argument as the only element of the result:

q) count (enlist (1;2;3))
1

The only solution I can see is to use a trick with folding similar to the one in the definition of replicate above.

map: { [f;xs]
	a: {x, (enlist z[y])};
	() a[ ; ;f]/ xs
	}

This works:

q)map[enlist; (1;2;3)]
1
2
3

I have decided to move with my family to Poland. I will be describing the experience on another blog.

I have released a new version of IsarMathLib. There are about 20 new theorems and a new theory on topological groups. The theory contains some basic definitions and notation and ends with a theorem that a subgroup of a topological group is a topological group.

Formalpedia is an “editable online repository of code and formal math”. It is on its way to became the first formalized mathematics wiki that goes online. Formalpedia is still read only, so it is not there yet. Mathematics on Formalpedia is (to be) verified by HOL Light. Most of the proofs are “not available yet”, but there are a couple that have been imported, so one can get the idea for how the presentation looks like. HOL Light verification scripts are known to be mostly write only, but one can see that the web presentation can help a lot in this respect. Formalpedia does use some mathematical notation and provides links to the “tactics” referenced in proofs. The assertion of a typical theorem looks like this:

Theorem (fact_divides_thm).

As we can see there is some confusing “Arith.fact” noise. Also for the theorem to be true the relation “” would have to somehow imply that are elements of some field. To understand how this happens I tried to click on symbol, but that does not lead to the definition of that symbol, but rather to the whole rather big file where I guess the definition is. But with proper links to definitions and some effort from the reader I believe verification scripts presented at Formalpedia can be converted into readable proofs. Allowing informal (but LaTeX enabled) text to be interleaved with the formal HOL Light text would greatly improve readability of mathematics for people who are not HOL Light users. Clickable symbols in mathematical formulas is a very good idea and I would like to have something like that in IsarMathLib presentation at FormalMath.org as well. I don’t think jsMath that displays the math there supports that though.

Formalpedia is clearly under development and it is good that the authors (author?) decided to post this early alpha version. It would be better if they provided an easy way for getting a feedback from viewers. I could not find any link to a forum, blog or even e-mail that would allow for that. Maybe I missed something.

The approach taken in the Haskell’s probability library makes it especially convenient for modeling Markov chains.
Suppose  is a Markov chain on a state space . Distribution of the process is determined by the distribution of and the numbers , , called transition probabilities. For simplicity let’s consider only time-homogeneous Markov chains where these numbers don’t depend on and let’s assume that the initial distribution is a point mass, i.e. for some . Then we can define a function , where for each the value is a distribution on defined by . Here denotes the set of finitely supported nonnegative functions on that sum up to 1. Conceptually, is the the distribution of the next value of the chain given the current value is . This is exactly the kind of distribution-valued function that is the right hand side operand of the operation from the previous post, which corresponds to the Haskell’s >>= operation in the probability monad.

The probability library’s Transition module contains a funtion called “compose” that allows to obtain the final distribution of a Markov chain given a list of transition functions and some initial value. Let’s consider a random walk as an example. Suppose we start from 0 and in each step we go up or down by 1 with the same probability. After importing Numeric.Probability.Distribution as D and Numeric.Probability.Transition as Tran we define the transition probabilities


rwtran :: Tran.T Double Int
rwtran x = D.choose 0.5 (x+1) (x-1)


Tran.T is the type of transition functions, that is functions that assign distributions on some type (Int in this case) to values from that type.
Now the final distribution of values after steps of this Markov chain starting from initial value can be calculated by


rw :: Int -> Int -> D.T Double Int
rw v n = (Tran.compose $ replicate n rwtran) v


Here replicate n rwtran creates a list of (identical) transition functions that is magicaly composed by compose into one transition function that takes us all the way from the initial value to the final distriibution. From GHCi the distrubution after 5 steps looks like this:

*ProbLib> rw 0 5
fromFreqs [(-1,0.3125),(1,0.3125),(-3,0.15625),(3,0.15625),(-5,3.125e-2),(5,3.125e-2)]

Using the ?? operator from the Distribution module we can ask about probability of some event, like what is the probability that after 10 steps the value is positive.

*ProbLib Numeric.Probability.Distribution> (>0) ?? (rw 0 10)
0.376953125

Sometimes the questions we want to ask are not about the the properties of the final random variable of a Markov chain, but about the whole path . For example suppose we want to know the probability that the random walk is never (up to n steps) negative. One way to do that is to consider another Markov chain whose state space is the set of sequences
The transition function takes a sequence of length and assigns a distribution on sequences of length in the obvious way. For our random walk example in Haskell we could write the following transition function


rwptran :: Tran.T Double [Int]
rwptran x = D.choose 0.5 (x ++ [(last x) + 1]) (x ++ [(last x) - 1])


And the distribution on the path space after n steps is calculated by


rwp :: Int -> Int -> D.T Double [Int]
rwp v n = (Tran.compose $ replicate n rwptran) [v]


For this particular process the distribution on the path space is not very interesting by itself as each path has the same probability.

*ProbLib Numeric.Probability.Distribution> rwp 0 3
fromFreqs [([0,-1,-2,-3],0.125),([0,-1,-2,-1],0.125),([0,-1,0,-1],0.125),
([0,-1,0,1],0.125),([0,1,0,-1],0.125),([0,1,0,1],0.125),([0,1,2,1],0.125),
([0,1,2,3],0.125)]

However, now we can ask questions related to paths. For example, what is the probability that in 10 steps we never go negative?

*ProbLib Numeric.Probability.Distribution> (all (>= 0)) ?? (rwp 0 10)
0.24609375

My favourite programming language Haskell has a nice library for doing calculations with probablility distributions, called probability.
The library was originally written by Martin Ewig and Steve Kollmansberger and then extended and packaged for convenient installation by Henning Thieleman. Its main idea for the implementation is to use the fact that “probability distributions form a monad” (from a paper by the authors of the library ). This post aims at translating this claim into standard probability notation and showing how it is used in the library.

Monad is a notion in category theory which is defined as a monoid in the category of endofunctors. That sounds so cool that I really wish I knew what it means. The only thing I know now is that the “monoid” here is not the standard monoid from mathematics founded on set theory, but rather its category theory analogue. So what does the claim “probability distributions form a monad” mean Haskell-wise?

Let’s load the library and play with it.

Prelude>:m +Numeric.Probability.Distribution

In the probability library distributions are (essentially) represented as lists of pairs (element, probability).
There are a couple of functions defined that provide means of generating some often used distributions. For example “choose p a b” will generate a distribution that assigns probability p to a value a and (1-p) to b.

Prelude Numeric.Probability.Distribution> choose 0.3 0 1

Loading package array-0.1.0.0 ... linking ... done.
Loading package containers-0.1.0.1 ... linking ... done.
Loading package mtl-1.1.0.0 ... linking ... done.
Loading package old-locale-1.0.0.0 ... linking ... done.
Loading package old-time-1.0.0.0 ... linking ... done.
Loading package random-1.0.0.0 ... linking ... done.
Loading package probability-0.2.1 ... linking ... done.
fromFreqs [(1,0.7),(0,0.3)]

Another example is the function “uniform” that assigns the same probability to all elements of a list.

Prelude Numeric.Probability.Distribution> uniform [0,1,2,3]

fromFreqs [(0,0.25),(1,0.25),(2,0.25),(3,0.25)]

There is also a function “certainly” that constructs a point mass

Prelude Numeric.Probability.Distribution> certainly 5

fromFreqs [(5,1)]

Now what about that monad thing? Let’s think about distributions on a given finite set as nonnegative functions that sum up to 1 and let be the set of such distributions. So, we have . Suppose now we have two finite sets . We can define a binary operation that takes a distribution on and a function that assigns a distribution on to every element of , and creates a distribution on in a (quite) natural way:

for any and .

By taking the sum over all it is easy to check that is indeed a distribution on . It can be interpreted as the distribution of the result of selecting first according to distribution and then selecting from the set according to the distribution given by .

We can use the “” (corresponding to Haskell’s “>>=”) operation to construct joint distributions. For example to generate o model of two coin tosses we can do

Prelude Numeric.Probability.Distribution>
(choose 0.5 0 1) >>= (\x -> choose 0.5 (x,0) (x,1))

fromFreqs [((0,0),0.25),((0,1),0.25),((1,0),0.25),((1,1),0.25)]

Now suppose we have three finite sets and corresponding operations in

and

that we will both denote . Then for all , and we have the identity , where is defined as .
Note that if then is a distribution on and for .

Let’s expand both sides to see that the identity really holds. Fix . We want to see that the values of the distributions  and are the same on .

The left hand side evaluates to

and on the right hand side we have

.

So they are the same.

The fact that we have such quasi-associativity (plus two other conditions that are trivial to check) allows to claim that the type of distributions forms a monad. In Haskell this opens up a whole world of possibilities. There are hundreds of functions related to monads in Haskell libraries. One can assume that each one does something useful when applied to probabilistic calculations and the only problem is to figure out what that useful thing is.
For example the function “replicateM” creates distributions of sequences of independent identically distributed random variables:

Prelude Numeric.Probability.Distribution> :m + Control.Monad
Prelude Numeric.Probability.Distribution Control.Monad>
replicateM 4 (choose 0.5 0 1)

fromFreqs [([0,0,0,0],6.25e-2),([0,0,0,1],6.25e-2),([0,0,1,0],6.25e-2),
([0,0,1,1],6.25e-2),([0,1,0,0],6.25e-2),([0,1,0,1],6.25e-2),([0,1,1,0],
6.25e-2),([0,1,1,1],6.25e-2),([1,0,0,0],6.25e-2),([1,0,0,1],6.25e-2),
([1,0,1,0],6.25e-2),([1,0,1,1],6.25e-2),([1,1,0,0],6.25e-2),
([1,1,0,1],6.25e-2),([1,1,1,0],6.25e-2),([1,1,1,1],6.25e-2)]

One can define a function that calculates the sequence of expectations of maximum of i.i.d random variables with common distribution as follows:

expmaxseq n d = [D.expected $ D.map maximum $ replicateM k d | k <- [1..n]]

For throwing dice we get the following expectations of maximum for 1,2,…, 7 dice:

ProbLib Numeric.Probability.Distribution> expmaxseq 7 (uniform [1..6])

[3.5,4.472222222222223,4.958333333333335,5.2445987654321105,
5.4309413580246915,5.560292352536542,5.65411736969124]

This release is  the first version of the IsarMathLib library for the new Isabelle2009. There is a little bit of new formalized mathematics as well.

The new CommutativeSemigroup_ZF theory is another take on the subject of summing up elements of some finite subset of a semigroup. This is similar to what was done in the Semigroup theory, but this time the approach is more specific to the case when the semigroup operation is commutative and does not require a linear order on the elements that we are summing up. This formalizes the definition of where is an indexed  family of elements of the semigroup and  is some finite subset of the index set. I have  written a bit about it that previously.

I also added a couple of theorems on the notion of lifting an operation to subsets. This is just a name I came up with for the operation on subsets of that is defined naturally by any binary operation on . I discussed this in the “Interval arithmetic in groups – pass  2” post.

The Isabelle team has released version 2009. Updating IsarMathLib to Isabelle 2009 was very easy. I only had to make a couple of corrections to proofs that used assumptions implicitly. The only more complicated change was related to renaming variables in the locale syntax.

Isabelle supports “locales” that are constructs that allow to limit the scope of definitions and notation. In IsarMathLib locales are used as kind of contexts  that hold certain assumptions and define notation specific to the some area of mathematics. For example, an IsarMathLib locale called ring0 contains an assumption that the sets form a ring. This locale assumption is then implicitly added to all theorems  proven in the locale. In case of the ring0 locale the set is the “carrier” of the ring, represents the addition and is the multiplication (recall that in ZF set theory binary operations are sets). Locales can form hierarchies in a way similar to classes in OO programming languages, inheriting assumptions and notation. In IsarMathLib locale field0 extends locale ring0 by adding an assumption that multiplicative inverses exist for all non-zero elements. Locales also allow to rename the variables inherited from the parent. In case of the field0 locale the carrier is named rather that , as is customary for fields. It is the syntax for renaming that got changed in Isabelle 2009. In Isabelle 2008 I could write

locale field0 = ring0 K

and the first variable in the ring0 locale could be used as in the field0 locale. For Isabelle 2009 it seems I have to write

locale field0 = ring0 K A M for K A M,

repeating the fixed sets of the locale twice. I can live with it, but it looks weird and programmish. The main reason I like the Isar proof language is that it is typically similar to what one would write in a standard (informal) mathematical proof. This change is a step away from this idea. I think it would be better to be able to write something like

locale field0 =  ring0 renaming R to K .

This way it would look a bit like Cobol and I am saying there is nothing wrong with that.

In addition to the old ProofGeneral interface the 2009 release contains an experimental interface written in Scala as a Jedit plugin. I am planning on checking that out.

Apparently the formalized mathematics project at Radboud University Nijmegen (NL) that I wrote about previously did get some funding after all and they are hiring two people to work on it. The PhD position is for 4 years and the postdoc position is 3 years. I hope that a usable formalized mathematics wiki will be available earlier.

The postdoc position pays a “maximum salary”  of 3755 Euro per month. Such wording immediately makes me curious what is the minimum … .