# Modelling Stochastically Independent Processes with F# Computation Expressions: Part 1

The idea for doing this is not new. There is an excellent series of posts closely tracing an article on applications of functional programming to probability.

A colleague of mine has recently called my attention to his own post of two years ago, where he describes a monad that models stochastically independent events in Clojure. I thought the latter implementation actually went to the heart of the whole idea of monads and that is why, once I started writing my own in F# from scratch, event though I naturally/brute-force-like, chose something described below and which corresponds exactly to the series of posts above, I eventually was compelled to do it my colleague’s way.

Here is the natural choice: a distribution (p.m.f) is just a sequence of events. Each event is simply a record/tuple/map of two values: the signifier of the event and its probability.

```//underlying type
type 'a Outcome = {
Value: 'a
Probability : BigRational  }

type 'a Distribution = 'a Outcome seq
```

This is great, and it works very well, as the posts show. My slight dissatisfaction with this approach is due to the fact that the competing one appears much more transparent, extremely easy to read, easy to use. In fact, anyone who knows Clojure syntax can use it right away to model independent processes simply by writing them out in Clojure, AND there is no need for any helper functions to extract the results. It just works (from the post, with some minor corrections):

```(domonad probability-m
[die1 (uniform [1 2 3 4 5 6])
die2 (uniform [1 2 3 4 5 6])]
(+ die1 die2))
```

This code models an experiment of rolling two dice and returns a probability mass function that describes the experiment. All we had to do as users was describe the experiment in the most natural way possible: what is the probability of getting an exact value as the sum of both values of 2 rolled dice. Hence the expression: extract the value from the first pmf, add it to the value extracted from the second. Don’t even need to think about probabilities, as the magic happens behind the monadic scene.

The code above gives us the result: {2 1/36, 3 1/18, 4 1/12, 5 1/9, 6 5/36, 7 1/6, 8 5/36, 9 1/9, 10 1/12, 11 1/18, 12 1/36} – which is a map of the sum of dice values to the probability of getting them. In F#, I believe, the Algol-like syntax actually works to our advantage (I call the computation expression “independent” for obvious reasons):

```independent {
let! x = uniform [1..6]
let! y = uniform [1..6]
return x + y
}
```

When executed in F# interactive, and using the FSharp.PowerPack:

```val mp : Map<int,BigRational> =
map
[(2, 1/36N); (3, 1/18N); (4, 1/12N); (5, 1/9N); (6, 5/36N); (7, 1/6N);
(8, 5/36N); (9, 1/9N); (10, 1/12N); ...]
```

We, amazingly enough, get the same answers. Next time: better examples and nuts & bolts of the code.

## 2 thoughts on “Modelling Stochastically Independent Processes with F# Computation Expressions: Part 1”

This site uses Akismet to reduce spam. Learn how your comment data is processed.