This post shows how a biased random walk can be implemented in OCaml as a recursive definition. Consider a walker whoes initial position is n where n is positive integer will go forward 1 step with probability 1/3 and will go backward 1 step with probability 2/3.

What we are interested in here is what is the number of steps that the walker needs to take to go from the position n to 0. Obviously, in the worst-case this number of steps is infinite. However, we can show that the probability that this situation happens is 0, e.g., it is 1/3^m where m go to infinity. We say that this random walk algorithm is almost sure termination.

Thus the more interesting question is what is the expected number of steps that the walker needs to take to go from n to 0. If we call T(n) is the expected number of steps to go from n to 0, then we have the following recursion relation T(n) = 1 + 1/3T(n+1) + 2/3T(n-1). The solution of this relation is T(n) = 3.n. However, the recursion relation solving is not easy problem. If we use our automatic analyzer, Absynth, that can infer the upper bound on this expected value, the we get the same tightest bound 3.max(0,n).


let rec biased_rw n counter =
   let () = assert (n >= 0) in match n with
   | 0 -> (0, counter)
   | _ -> 
    let r = 100 in
    (* encode the probability 2/3 *)
    if (r < 67) then 
        biased_rw (n-1) (counter+1) 
        biased_rw (n+1) (counter+1)

(* testing function *)
let test nr f n =
   let rt = ref 0 in
   for i = 1 to nr do
      let (_,cost) = f n 0 in
      rt := (!rt) + cost
   (float_of_int (!rt)) /. (float_of_int nr)

The following are the average values of counter when we run biased_rw for 10000 times.

# test 10000 biased_rw 10;;
- : float = 29.472