# Parrondo's Paradox, or how to win by randomly losing

Gambling enjoys a negative reputation, which is perhaps deserved, because the games gamblers play are designed in such a way that the chances of winning are just slightly smaller than the chances of losing. This makes gambilng a losing activity in the long run. In what follows, I am going to describe two betting games which are both losing, however a strategy of randomly playing these losing games turns out to be very interesting indeed.

**Losing Game A**

The first example of a losing game has the probability of winning
*p = 1/2 - e*, where *e* is a very
small number. For illustration, let's assume that we make 1000
successive bets getting $1 if we win, and losing $1 otherwise. The
simulation below runs our game 100 times, and shows that on average we
expect to lose about $15 (for *e = 0.005*).

import random from __future__ import division e = 0.005 def game_A(m): return m + 1 if random.random() < (1/2 - e) else m - 1 def simulate(n_runs, n_bets, game_fn): runs = np.zeros((n_runs, n_bets)) for i in range(n_runs): money = [] m = 0 for _ in range(n_bets): m = game_fn(m) money.append(m) runs[i, :] = money return np.mean(runs, 0) avg_money = simulate(100, 1000, game_A) plot(avg_money);

**Losing Game B**

The rules of the second game are a bit more complicated. If the current
amount of money is a multiple of 3, then the probability to win is
*1/10 - e*, otherwise the probability to win is
*3/4 - e*. The simulation below shows that game B
is also a losing game, as we are expected to lose around $12 after 1000
successive bets.

def game_B(m): if m % 3 == 0: return m + 1 if random.random() < 1/10 - e else m - 1 else: return m + 1 if random.random() < 3/4 - e else m - 1 avg_money = simulate(100, 1000, game_B) plot(avg_money);

**Randomly switching between games A and B**

Now we have two losing games, A and B. What if we made 1000 bets randomly switching back and forth between these two games, sure we would also end up losing, right? Surprisingly no! It looks like if we just randomly switch between the two losing bets, we actually win! (about $15 after 1000 bets)

def game_AB(m): if random.random() < 0.5: return game_A(m) else: return game_B(m) avg_money = simulate(100, 1000, game_AB) plot(avg_money);

The surprising behavior described above was first discovered by Juan Parrondo in 1996. I came accross it this year, while reading the book Digital Dice which I would totally recommend as an interesting read.

An interesting observation is that Parrondo's paradox only works if
*e* is small enough. The figure below plots how much can be
won after 1000 bets for different values of *e*. We notice
that if *e = 0* we make the most money (+$30), while for
values greater than 0.01 this random switching game stops being
profitable. In the case of betting on a color in roulette
*e = 0.0263*, which is not small enough.

e_vals = np.linspace(0, 0.05, 100) avg_won = [] for e in e_vals: avg_money = simulate(100, 1000, game_AB) avg_won.append(avg_money[-1])

fig, ax = plt.subplots(1,1) ax.plot(e_vals, avg_won); ax.set_xlim(0, 0.03); ax.set_ylim(-40, 40); ax.set_xlabel('values for epsilon'); ax.set_ylabel('amount won after 1000 bets'); ax.plot([0, 0.03], [0,0], 'r-');