Debunking Roulette Strategies and Stopping Rules: A Monte Carlo Study

Let’s start off by loading the required packages for this blog post. Nothing fancy, just data structures and plotting libraries.

# Data Wrangling
import polars as pl
import pandas as pd
import numpy as np

# Utils
import random
import os
from tqdm.notebook import tqdm
from IPython.display import clear_output, display

# Visualisation
import plotnine as pn
import matplotlib.font_manager as fm
from mizani.formatters import (
    comma_format,
    percent_format,
)

project_dir = os.getcwd()
font_path = os.path.join(project_dir, "lmroman10-regular.otf")
prop = fm.FontProperties(fname=font_path)

# Color palettes for visualization (inspired by JAMA, and extended with some more colors)
PALETTE = [
    "#374E55FF",  # Dark Slate Gray
    "#8F44FFFF",  # Purple
    "#00A1D5FF",  # Blue
    "#B24745FF",  # Red
    "#79AF97FF",  # Sea Green
    "#6A6599FF",  # Purple
    "#80796BFF",  # Brown
    "#FFC107FF",  # Mustard Yellow
    "#00C49AFF",  # Teal
    "#FF7043FF",  # Coral
    "#003366FF",  # Navy Blue
    "#66BB6AFF",  # Mint Green
    "#BA68C8FF",  # Light Purple
    "#8B0000FF",  # Burgundy
    "#556B2FFF",  # Olive Green
    "#FFD700FF",  # Gold
    "#40E0D0FF",  # Turquoise
    "#E6E6FAFF",  # Lavender
    "#800000FF",  # Maroon
    "#A0522DFF",  # Sienna Brown
]

# A remnant of my master's thesis, feel free to yoink
THEME_ACADEMIC = pn.theme(
    text=pn.element_text(fontproperties=prop),
    plot_title=pn.element_text(size=14, ha="center"),
    legend_text=pn.element_text(size=10),
    legend_title=pn.element_text(size=10),
    panel_background=pn.element_rect(fill="white"),
    panel_border=pn.element_rect(color="grey", size=0.5),
    axis_ticks=pn.element_line(color="grey"),
    panel_grid_major=pn.element_line(color="grey", size=0.1, alpha=0.75),
    panel_grid_minor=pn.element_line(color="grey", size=0.1, alpha=0.75),
    legend_background=pn.element_rect(fill="white", color=None),
    legend_key=pn.element_rect(fill="white", color=None),
    legend_position="right",
    legend_key_size=8,
    plot_margin=0.02,
    figure_size=(8, 4),
)

Introduction

Let’s start of by addressing the elephant in the room: Of course intuition tells us that the casino always wins. From an economic perspective alone, casinos worldwide would have been run into the ground if that wasn’t the case.

However, there is no shortage of Youtubers or influencers promoting gambling on various platforms nowaways trying to convince the youngest generation of the opposite. I’ll mention two categories of them that particularly rub me the wrong way:

1. Youtubers promoting “winning strategies” on age-old games like roulette, claiming winning percentages of up to 90% with their “foolproof” strategies. They often market to crowds above 30 and sell a false sense of hope to people who are looking for ways to make quick money.

2. Streamers dabbling in substance abuse and promoting gambling to their underage audience, often backed financially by gambling platforms like Rainbet or Stake. They exploit the naivety of their audience, often teenagers below 18.

So given this context, I want to embark on a brief mission of showing that it doesn’t need much more than mediocre coding skills to debunk these clowns fairly easily (if intuition and common sense fail).

I’ll show two things:

1. Strategies around Roulette: First, a common misconception of trying to walk when you’re up. If you could repeat this, then you’d surely become profitable. Right…? Additionally, I’ll simulate a couple of the above-mentioned Youtuber strategies and lose my cool about them.
2. Plinko: A particularly popular game among streamers, where you drop small balls down a pegboard and try to hit the highest paying slots at the bottom. The configurability of the game gives gamblers a false sense of control, which we can easily show using the Binomial distribution.

Roulette

Defining the Class

I’ll start by creating a simple class emulating a European Roulette wheel exactly like the one you’ll find in Swiss casinos.

There are more types of bets you can do that betting on numbers, colours, columns or dozens, but these are the only ones we need for the below simulations, so I’ll keep the class short:

class SwissRoulette:
    """
    European/Swiss Roulette with single zero (0-36).
    Supports colour, dozen, column, and straight-up bets.
    """

    def __init__(self, seed=None):
        self.rng = random.Random(seed) if seed is not None else random.Random()

        self.numbers = list(range(37))

        red = {1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36}
        self.colors = {
            i: "green" if i == 0 else "red" if i in red else "black" for i in range(37)
        }

        self.columns = {
            1: [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34],
            2: [2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35],
            3: [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36],
        }

        self.payoffs = {
            "straight_up": 35,
            "dozen": 2,
            "column": 2,
            "red": 1,
            "black": 1,
        }

    def spin(self):
        n = self.rng.choice(self.numbers)
        return n, self.colors[n]

    def check_bet(self, bet_type, bet_value, result_number, result_color):
        if bet_type == "straight_up":
            return result_number == bet_value
        elif bet_type == "dozen":
            if bet_value == 1:
                return 1 <= result_number <= 12
            if bet_value == 2:
                return 13 <= result_number <= 24
            if bet_value == 3:
                return 25 <= result_number <= 36
        elif bet_type == "column":
            return result_number in self.columns[bet_value]
        elif bet_type == "red":
            return result_color == "red"
        elif bet_type == "black":
            return result_color == "black"
        else:
            raise ValueError(f"Unknown bet type: {bet_type}")

    def place_bet(self, bet_type, bet_value, stake=1):
        number, color = self.spin()
        win = self.check_bet(bet_type, bet_value, number, color)
        payout = stake * (self.payoffs[bet_type] + 1) if win else 0
        return {
            "result_number": number,
            "result_color": color,
            "win": win,
            "payout": payout,
        }

    def place_multiple_bets(self, bets):
        number, color = self.spin()
        total_stake = sum(b["stake"] for b in bets)
        total_payout = 0
        bet_results = []

        for b in bets:
            win = self.check_bet(b["type"], b["value"], number, color)
            payout = b["stake"] * (self.payoffs[b["type"]] + 1) if win else 0
            total_payout += payout
            bet_results.append(
                {
                    "type": b["type"],
                    "value": b["value"],
                    "stake": b["stake"],
                    "win": win,
                    "payout": payout,
                }
            )

        return {
            "result_number": number,
            "result_color": color,
            "total_stake": total_stake,
            "total_payout": total_payout,
            "net_result": total_payout - total_stake,
            "bet_results": bet_results,
        }

With this done, let’s get simulating.

Just walk when you’re up!?

Many players seem to believe that you can play until you are up, then walk out of the casino. Just repeat that the next day.

Here is an actual Youtube Comment I found about this strategy:

Let’s do a realistic Monte Carlo simulation of this strategy. You start with a certain capital (e.g. 10k), and you play until either you lose everything or you reach a certain profit target, at which point you walk away.

First, let’s assume a few things:

Assumption	Justification
Initial player capital = 10k	Let’s simulate someone convinced of their strategy.
Bet Size = 30	Seems a reasonably sized bet, not too large or too small
Games per hour = 30	1 game every 2 minutes seems even on the conservative side
Hours played = 3 (per session/day)	Let’s say the day job still takes precedence
Players bets on colours	Most popular bet on the roulette table
1 year of playing this strategy	Sufficiently long to give the results some statistical significance

initial_capital = 10_000
min_bet_size = 30
games_per_hour = 30
hours_played = 3

total_games = games_per_hour * hours_played
total_games

90

This amounts to 90 games per day/session in the casino.

Let’s assume a very dedicated player who plays every single day for a year (365 days).

Here’s the code for the simulation:

• Looping through 365 days: Every day is a new “reset” as per the logic of the better above (new seed for every day).
• Playing 90 games consecutively on the same table. Always betting on red, because switching it up really doesn’t matter (see Gambler’s fallacy).
• Capital grows by the payout: \(\text{Capital}_{t+1} = \text{Capital}_t - \text{Bet Size} + \text{Payout}_i\)
  • Win: Positive growth (Payout > Bet Size)
  • Loss: Negative growth (Payout = 0)

results = []
simulations = 365

for s in tqdm(range(simulations)):
    capital = initial_capital
    capital_path = []

    roulette = SwissRoulette(seed=s)

    for _ in range(total_games):
        # Spin
        result = roulette.place_bet(bet_type="red", bet_value=None, stake=min_bet_size)

        # Update capital
        capital += result["payout"] - min_bet_size
        capital_path.append(capital)

    betpath = pl.DataFrame(
        {"simulation": s, "betnum": range(len(capital_path)), "capital": capital_path}
    )

    results.append(betpath)


df = pl.concat(results, how="vertical")

(
    pn.ggplot()
    + pn.geom_line(
        data=df,
        mapping=pn.aes("betnum", "capital", group="simulation"),
        alpha=0.05,
        colour="grey",
    )
    + pn.geom_line(
        data=df.filter(pl.col("simulation") == 2),
        mapping=pn.aes("betnum", "capital"),
        colour="blue",
    )
    + pn.geom_line(
        data=df.group_by("betnum").agg(capital=pl.mean("capital")),
        mapping=pn.aes("betnum", "capital"),
        colour="red",
    )
    + pn.labs(
        title="365 Days at the Roulette Table",
        x="Number of Bets Placed",
        y="Capital (CHF)",
    )
    + pn.geom_hline(yintercept=initial_capital, linetype="dashed", color="black")
    + pn.scale_x_continuous(breaks=range(0, total_games + 1, 10))
    + pn.scale_y_continuous(labels=comma_format())
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 3))
)

If you were to spend 3 hours a day playing roulette, these are all the daily paths you could have encountered over a year of playing. I highlighted one of them in blue to show the source of the idea of the Youtube comment above: This particular day, the player was up briefly before losing. What if they had just walked away when they were up…?

The main question is: When do you stop playing and go home with a positive balance? Do you only walk if you reached a certain minimum hourly salary level? After all, if you only earn 5 CHF an hour, you could have just taken the evening shift at McD from a financial perspective.

So let’s make this a realistic simulation grounded in practical assumptions:

Assumption	Justification
Minimum required hourly salary level to walk = 15	Walk when you’re you’ve reached a minimum hourly salary of 15 CHF. Below this, you won’t get far in Switzerland unfortunately and you should just try to find another side-hustle.
100,000 MC simulations	To give the findings some statistical significance

Expected Value (EV) of “Walking when up”

Any game with an expected value above 0 will earn you money in the long-run. Any EV below 0 and you’ll be wasting your time. Of course, the Casino will only let you play negative EV games (from your perspective, as it is positive EV for them), but we’re past the point of arguing qualitatively, let’s show the numbers how they would develop “long-term” for the player.

people = 100_000  # Simulating the lives of 100,000 people playing roulette for a year

people_dfs = []

# This runs 30 minutes in Python, definitely room for vectorisation and parallelization
# but I not a high priority for this blog post
for p in tqdm(range(people)):

    min_bet_size = 30
    games_per_hour = 30
    hours_played = 3
    total_games = games_per_hour * hours_played
    simulations = 365

    min_hourly_salary = 15
    current_capital = 10_000

    results = []

    # One simulation = 1 day of playing
    for s in range(simulations):

        # Start with yesterday's capital and save the starting balance
        capital_start_of_day = current_capital
        capital_path = []

        # Set seed to day number for reproducibility
        roulette = SwissRoulette()

        # Play up to total_games
        for g in range(total_games):

            # Gamble
            result = roulette.place_bet(
                bet_type="red", bet_value=None, stake=min_bet_size
            )

            # Add result to P&L
            current_capital += result["payout"] - min_bet_size

            # Store capital path
            capital_path.append(current_capital)

            # Break Condition 1) Bust: no more capital to place a bet
            if current_capital < min_bet_size:
                # print("Tough luck mate, busted")
                break

            # Break Condition 2) Earned enough: If minimum hourly salary reached, go home
            hours_played = (g + 1) / games_per_hour
            current_hourly_salary = (
                current_capital - capital_start_of_day
            ) / hours_played
            # print(
            #     f"Current hourly salary: {current_hourly_salary:.2f} after {hours_played:.2f} hours"
            # )

            if current_hourly_salary >= min_hourly_salary:
                break

        # Break Condition 1) Bust: no more capital to place a bet
        if current_capital < min_bet_size:
            # print("Can't do another day, already bust")
            break

    result = pl.DataFrame(
        {
            "simulation": s,
            "betnum": range(len(capital_path))[-1],
            "capital": capital_path[-1],
            "person": p,
        }
    )

    people_dfs.append(result)

pl.concat(people_dfs, how="vertical").to_pandas().to_csv(
    "roulette_colour_bets_simulation.csv", index=False
)

df = pl.read_csv("roulette_colour_bets_simulation.csv")

(
    pn.ggplot(
        data=df,
        mapping=pn.aes("capital"),
    )
    + pn.labs(
        title="100,000 Players after 1 Year of Walking When Up",
        x="Final Capital (CHF)",
        y="Number of Players",
    )
    + pn.geom_histogram(bins=30)
    + pn.geom_vline(xintercept=10_000, linetype="dashed", color="black")
    + pn.scale_x_continuous(labels=comma_format(), breaks=np.arange(0, 20000, 2000))
    + pn.scale_y_continuous(labels=comma_format())
    + THEME_ACADEMIC
    + pn.theme(figure_size=(8, 4))
)

print(f"{df['capital'].mean():,.0f} CHF average final capital after 1 year")
print(
    f"Less than {df['capital'].quantile(0.1):,.0f} CHF balance for unluckiest 10% of players after 1 year"
)
print(
    f"More than {df['capital'].quantile(0.9):,.0f} CHF balance for luckiest 10% of players after 1 year"
)

5,176 CHF average final capital after 1 year
Less than 1,690 CHF balance for unluckiest 10% of players after 1 year
More than 8,500 CHF balance for luckiest 10% of players after 1 year

The numbers are looking dire: If you’re trying this strategy, you are better off just walking out before the first bet and you’ll be in the upper 3% of players just based on initial capital.

(
    pn.ggplot(
        data=df.sample(1000),
        mapping=pn.aes("capital"),
    )
    + pn.stat_ecdf()
    + pn.labs(
        title="CDF of Final Capital After 1 Year of Walking When Up",
        x="Final Capital (CHF)",
        y="Proportion of Players",
    )
    + pn.scale_x_continuous(
        breaks=np.arange(0, initial_capital + 5e3, 1000), labels=comma_format()
    )
    + pn.scale_y_continuous(breaks=np.arange(0, 1.1, 0.1), labels=percent_format())
    + THEME_ACADEMIC
    + pn.theme(figure_size=(7, 5))
)

When looking at the Cumulative Distribution Function, it becomes clear that less than 5% of players are actually increasing their capital. Only around 1% even make 10% on this strategy. You are better off buying the S&P500 and waiting a year and it will save you from a gambling addiction while you’re at it.

Conclusion: Don’t walk when up, just don’t walk in.

Removing the Edge of the House

The issue with the above strategy is the edge of the house.

The board and payoffs are designed to give the house a statistical edge. Firstly, the payoffs are not inversely proportional to the frequency of winning bets: For instance, betting on any number of the 37 fields will give you a payoff of 1:35, so give you back 36 CHF for putting up 37 CHF on all fields.This gives the house an edge of 2.7% (1/37).

Additionally, there is a green zero among the numbers, which makes you lose your stake when not betting on it when the payoff is actually inversely proportional (for example betting on colours, 1:2 payoff, but 1/37 chance of losing stake due to hitting 0). And before you get too excited and think “What if we just bet on the zero every time?”, remember that the payout is 35:1, meaning you would need to win at least once every 36 spins to break even, which is not how the uniform nature of the Roulette wheel works.

Just to entertain the thought, let’s see what happens if we remove the zero from the wheel entirely.

# Parameters
people = 100_000
min_bet_size = 30
games_per_hour = 30
total_games = games_per_hour * 3  # 90 spins/day
simulations = 365
min_hourly_salary = 15
initial_capital = 10_000

rng = np.random.default_rng(42)

records = []

for p in tqdm(range(people)):
    current_capital = initial_capital

    for s in range(simulations):
        capital_start_of_day = current_capital

        # Vectorised: generate all spins for the day at once (+1 or -1)
        outcomes = rng.choice([-min_bet_size, min_bet_size], size=total_games)
        capital_path = capital_start_of_day + np.cumsum(outcomes)

        # Break condition 1: bust (rolled into path scan below)
        bust_mask = capital_path < min_bet_size

        # Break condition 2: hourly salary target reached
        hours_elapsed = (np.arange(total_games) + 1) / games_per_hour
        hourly_salary = (capital_path - capital_start_of_day) / hours_elapsed
        salary_mask = hourly_salary >= min_hourly_salary

        # Find first stopping spin (whichever condition fires first)
        stop_mask = bust_mask | salary_mask
        if stop_mask.any():
            stop_idx = int(np.argmax(stop_mask))
        else:
            stop_idx = total_games - 1

        current_capital = float(capital_path[stop_idx])

        # Bust check between days
        if current_capital < min_bet_size:
            break

    records.append((s, stop_idx, current_capital, p))

df = pl.DataFrame(
    records,
    schema=["simulation", "betnum", "capital", "person"],
    orient="row",
)

df.write_csv("roulette_colour_bets_simulation_fair.csv")

df = pl.read_csv("roulette_colour_bets_simulation_fair.csv")

(
    pn.ggplot(
        data=df,
        mapping=pn.aes("capital"),
    )
    + pn.geom_histogram(bins=30)
    + THEME_ACADEMIC
)

print(f"{df['capital'].mean():,.0f} CHF average final capital after 1 year")
print(
    f"Less than {df['capital'].quantile(0.1):,.0f} CHF balance for unluckiest 10% of players after 1 year"
)
print(
    f"More than {df['capital'].quantile(0.9):,.0f} CHF balance for luckiest 10% of players after 1 year"
)

Clearly, the house edge is what ruins the walk when up strategy, but the requirement for hitting an hourly salary to make it worthwile still leads to an asymmetric distribution of losers. However, because the capital is essentially a random walk, there is no way of changing the strategy and knowing when you will have “a good run”. This lack of information completely destroys any hope of making this strategy worth it, even with the house edge gone.

Youtube “Strategies”

Having shown that you can’t really just walk when you’ve won some cash, let’s get right into disproving “Youtubers” (scammers having found an upload button really) pretending they have a strategy that beats the house.

Apologies in advance for the level of emotional investment in this, it’s just the lowest level of predatory grifting one can resort to, short of straight up committing robbery.

BolderBets 90% Win Strategy

This video suggests a “Roulette strategy where you only miss on 4 numbers and that’s it”.

You risk: 300$

Place:

• 100$ on the second dozen
• 100$ on the third dozen
• 10$ on the 12, 11, 10, 9, 8, 7, 6, 5, 4 and 3

You only miss on: 0, 1 and 2.

This claims a 90% chance of making money.

Let’s define the strategy using our class:

# Define strategy
roulette = SwissRoulette(69)
strategy_bets = [
    {"type": "dozen", "value": 2, "stake": 100},  # Second dozen (13-24)
    {"type": "dozen", "value": 3, "stake": 100},  # Third dozen (25-36)
    {"type": "straight_up", "value": 3, "stake": 10},
    {"type": "straight_up", "value": 4, "stake": 10},
    {"type": "straight_up", "value": 5, "stake": 10},
    {"type": "straight_up", "value": 6, "stake": 10},
    {"type": "straight_up", "value": 7, "stake": 10},
    {"type": "straight_up", "value": 8, "stake": 10},
    {"type": "straight_up", "value": 9, "stake": 10},
    {"type": "straight_up", "value": 10, "stake": 10},
    {"type": "straight_up", "value": 11, "stake": 10},
    {"type": "straight_up", "value": 12, "stake": 10},
]

initial_capital = 10_000
spins = 10_000
capital = initial_capital

results = []
result_dfs = []

for s in tqdm(range(spins)):

    if capital <= sum([x["stake"] for x in strategy_bets]):
        break

    # Spin the wheel
    result = roulette.place_multiple_bets(
        strategy_bets,
    )

    # Get payout or lose stake
    for x in result["bet_results"]:
        if x["win"]:
            capital -= x["stake"]
            capital += x["payout"]
        else:
            capital -= x["stake"]

    results.append(result)
    result_dfs.append(pl.DataFrame({"betnum": s, "capital": capital}))

(
    pn.ggplot(pl.concat(result_dfs), pn.aes("betnum", "capital"))
    + pn.labs(
        title="One run of BolderBet's 90% Win Strategy", x="Bet Number", y="Capital"
    )
    + pn.scale_y_continuous(labels=comma_format())
    + pn.geom_step()
    + THEME_ACADEMIC
)

This path does not look promising, we’re bust after 2500 bets with a consistently losing trend. Where is the 90% win rate???

Let’s investigate the cumulative average win rate over time, which will converge to the true win rate given the law of large numbers:

wins = []

for x in results:
    win = 0
    for b in x["bet_results"]:
        if b["payout"] > 0:
            win = 1

    wins.append(win)

(
    pn.ggplot(
        (
            pl.DataFrame(
                {
                    "betnum": range(len(results)),
                    "win": wins,
                }
            ).with_columns(pl.col("win").cum_sum() / pl.col("win").cum_count())
        ),
        pn.aes("betnum", "win"),
    )
    + pn.labs(
        x="Number of Bets Placed",
        y="Proportion of Winning Spins",
    )
    + pn.geom_line()
    + pn.scale_y_continuous(
        labels=percent_format(), limits=(0, 1), breaks=np.arange(0, 1.1, 0.1)
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

There it is! This strategy actually let’s you win 90% of the time. So, let’s bet the house on it, right?

Expected Value of BolderBets 90% Win Strategy

No, we shouldn’t.

The problem is that the win rate by itself says nothing about the expected value. EV is calculated as the weighted average of the probability of each outcome multiplied by the financial result for each outcome.

Due to the risk of losing 300$ in one spin compared to small potential gains of 60$ or going flat, the expected value is negative.

In this case, we have three possible outcomes of the strategy:

• We lose and gain nothing: 0 CHF payout, almost 70% of the time.
• We win 60 CHF around 26% of the time.
• We lose our 300 CHF stake only around 7% of the time.

This looks promising at first, especially if you go as far as saying being flat is part of the “winning” bets.

counts = (
    pl.DataFrame({"net_result": [x["net_result"] for x in results]})["net_result"]
    .value_counts(sort=True)
    .with_columns(
        (pl.col("count") / pl.col("count").sum()).round(2).alias("proportion")
    )
)

counts

shape: (3, 3)

net_result	count	proportion
i64	u32	f64
0	1501	0.68
60	573	0.26
-300	147	0.07

However, if you actually multiply each probability with the respective outcome, you get to EV:

(
    counts.with_columns(name=pl.lit("Expected Value"))
    .group_by("name")
    .agg((pl.col("proportion") * pl.col("net_result")).sum().alias("CHF"))
)

shape: (1, 2)

name	CHF
str	f64
"Expected Value"	-5.4

And who would have thought? It’s negative.

Taking the empirical numbers from the simulation, the expected value shows you’re losing 5.40 CHF per spin on average. This is quite significant, as it amounts to losing around 500 CHF over the course of a session (3+ hours of play).

500 CHF loss over one evening with this strategy, let that sink in a minute and then remind yourself of the absolute smugness of the “Youtuber” above pushing people into a gambling addiction based on false promises. You could easily lose multiple days of your honest salary with this strategy just in one evening.

Let’s stretch the limits of the “win rate” definition of our snake-oil salesman above further and see if we can get a 100% win rate:

It’s as easy as placing on all fields, 10 CHF each, 370 CHF stake. Buy my course!!!

# Define strategy
roulette = SwissRoulette(69)
strategy_bets = [{"type": "straight_up", "value": i, "stake": 10} for i in range(0, 37)]

initial_capital = 10_000
simulations = 10_000
capital = initial_capital

results = []
result_dfs = []

for s in tqdm(range(simulations)):

    if capital <= sum([x["stake"] for x in strategy_bets]):
        break

    # Spin the wheel
    result = roulette.place_multiple_bets(
        strategy_bets,
    )

    # Get payout or lose stake
    for x in result["bet_results"]:
        if x["win"]:
            capital -= x["stake"]
            capital += x["payout"]
        else:
            capital -= x["stake"]

    results.append(result)
    result_dfs.append(pl.DataFrame({"betnum": s, "capital": capital}))

Here is the average win rate over time:

wins = []

for x in results:
    win = 0
    for b in x["bet_results"]:
        if b["payout"] > 0:
            win = 1

    wins.append(win)

(
    pn.ggplot(
        (
            pl.DataFrame(
                {
                    "betnum": range(len(results)),
                    "win": wins,
                }
            ).with_columns(pl.col("win").cum_sum() / pl.col("win").cum_count())
        ),
        pn.aes("betnum", "win"),
    )
    + pn.geom_line()
    + pn.scale_y_continuous(labels=percent_format(), limits=(0, 1))
    + pn.labs(
        x="Number of Bets Placed",
        y="Proportion of Winning Spins",
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

And here is the capital development:

(
    pn.ggplot(pl.concat(result_dfs), pn.aes("betnum", "capital"))
    + pn.geom_step()
    + pn.labs(
        x="Number of Bets Placed",
        y="Capital (CHF)",
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

Of course, you wager 370 CHF every round, but get back only 360 CHF (350 CHF win plus stake of 10 CHF of winning field). The house has the in-built edge ingrained in the payout structure, which gives you 1:35 payoffs despite there being 37 fields on the board. You’re giving the casino free money, but you’re winning 100% of the time, semantics I guess.

Let’s get back to inspecting the BolderBet’s strategy: The expected value only tells us about the expected value.

What if I’m god’s most precious creature and am feeling particularly lucky?

The world works in distributions, so let’s see what the outliers are doing:

# Define strategy
roulette = SwissRoulette(69)
strategy_bets = [
    {"type": "dozen", "value": 2, "stake": 100},  # Second dozen (13-24)
    {"type": "dozen", "value": 3, "stake": 100},  # Third dozen (25-36)
    {"type": "straight_up", "value": 3, "stake": 10},
    {"type": "straight_up", "value": 4, "stake": 10},
    {"type": "straight_up", "value": 5, "stake": 10},
    {"type": "straight_up", "value": 6, "stake": 10},
    {"type": "straight_up", "value": 7, "stake": 10},
    {"type": "straight_up", "value": 8, "stake": 10},
    {"type": "straight_up", "value": 9, "stake": 10},
    {"type": "straight_up", "value": 10, "stake": 10},
    {"type": "straight_up", "value": 11, "stake": 10},
    {"type": "straight_up", "value": 12, "stake": 10},
]

# Simulation parameters
people = 1_000
initial_capital = 50_000
simulations = 30_000
TARGET_DIR = "C:/Users/mathi/Documents/Python/Casino Blog Post/BolderBets"

# Run simulations for multiple people
people_dfs = []

for p in tqdm(range(people)):

    capital = initial_capital
    capital_path = []
    wins = []

    for s in range(simulations):

        # Check if we have enough capital to place all bets
        total_stake = sum([x["stake"] for x in strategy_bets])

        # No further bet if bust, but keep recording last capital position
        # for correct calculation of mean
        if capital <= total_stake:
            capital_path.append(capital)
            wins.append(spin_win)
            continue

        # Spin the wheel
        result = roulette.place_multiple_bets(strategy_bets)

        # Process bet results
        spin_win = 0
        for x in result["bet_results"]:
            capital += x["payout"] - x["stake"]
            spin_win = 1

        capital_path.append(capital)
        wins.append(spin_win)

    person_df = pl.DataFrame(
        {
            "betnum": range(len(capital_path)),
            "win": wins,
            "capital": capital_path,
            "person": p,
        }
    ).to_pandas()

    person_df.to_csv(
        f"{TARGET_DIR}/result.csv",
        mode="a",
        header=not os.path.exists(f"{TARGET_DIR}/result.csv"),
        index=False,
    )

# Load and aggregate results
df = pl.scan_csv(f"{TARGET_DIR}/result.csv")

ribbon_data = (
    df.group_by("betnum")
    .agg(
        q001=pl.col("capital").quantile(0.001),
        q01=pl.col("capital").quantile(0.01),
        q10=pl.col("capital").quantile(0.1),
        q25=pl.col("capital").quantile(0.25),
        mean=pl.col("capital").mean(),
        q75=pl.col("capital").quantile(0.75),
        q90=pl.col("capital").quantile(0.9),
        q99=pl.col("capital").quantile(0.99),
        q999=pl.col("capital").quantile(0.999),
    )
    .sort("betnum")
    .collect()
)

# Create ribbon layers
ribbon_layers = [
    {"ymin_col": "q001", "ymax_col": "q999", "label": "0.1%-99.9%"},
    {"ymin_col": "q01", "ymax_col": "q99", "label": "1%-99%"},
    {"ymin_col": "q10", "ymax_col": "q90", "label": "10%-90%"},
    {"ymin_col": "q25", "ymax_col": "q75", "label": "25%-75% (IQR)"},
]

ribbon_long = pl.concat(
    [
        ribbon_data.select(
            [
                "betnum",
                pl.col(layer["ymin_col"]).alias("lower"),
                pl.col(layer["ymax_col"]).alias("upper"),
                pl.lit(layer["label"]).alias("quantile_range"),
            ]
        )
        for layer in ribbon_layers
    ]
).with_columns(
    pl.col("quantile_range").cast(
        pl.Enum(["0.1%-99.9%", "1%-99%", "10%-90%", "25%-75% (IQR)"])
    )
)

mean_path = ribbon_data.select("betnum", "mean").with_columns(type=pl.lit("Average"))

# Create the plot
(
    pn.ggplot()
    + pn.geom_ribbon(
        data=ribbon_long,
        mapping=pn.aes("betnum", ymin="lower", ymax="upper", fill="quantile_range"),
    )
    + pn.geom_line(
        data=mean_path,
        mapping=pn.aes("betnum", "mean", colour="type"),
    )
    + pn.scale_fill_manual(values=["#C5D5E8", "#8FADD8", "#5985C8", "#2F5D9E"])
    + pn.labs(
        title=f"""{people} Simulations of BolderBets' "90% Win Strategy" """,
        x="Bet Number",
        y="Capital Balance",
        fill="Quantiles",
        colour="",
    )
    + pn.scale_x_continuous(labels=comma_format(), breaks=np.arange(0, 100_000, 1_000))
    + pn.scale_y_continuous(labels=comma_format(), breaks=np.arange(0, 110_000, 10_000))
    + pn.coord_cartesian(xlim=(0, 10_000))
    + pn.geom_hline(yintercept=initial_capital, linetype="dotted")
    + pn.scale_colour_manual(values=["firebrick"])
    + THEME_ACADEMIC
    + pn.theme(panel_grid_minor=pn.element_blank())
)

The red line shows the expected value of the player’s capital over time.

The channels show the quantiles of the capital distribution of 1,000 players over time. Clearly, even the luckiest 0.1 % of players’ capital is in free-fall.

This 90% winning strategy has 100% chance of ruining your life.

Cruise Ship Gambling’s Fibonacci’s Dozens Golden Entry

Here is another video, which claims:

“This is unbeatable, it really is, you got a really small chance of losing with this, probably 0.3%”

Let’s skip over the “probably 0.3%” (are we just making numbers up?) part and see how it works:

• Start with 5$
• Every time you lose, your next bet is going to be the sum of the previous 2 bets following the Fibonacci Sequence: 1,1,2,3,5,8,13,21,34,55,89

Another banger quote from the video is:

Follow the winner: “I found it’s better to move to the winning column, because invariably, that’s gonna hit two in a row. […] If a column appeared 5 times in a row, change to the other ones because that one is not gonna appear again with high likelihood.”

So there’s a lot to untangle here.

1. Gambler’s fallacy
   • Probability has no memory, the Roulette table is an example of an independent random variable and it does not matter in the slightest if red has come up 3 billion times in a row. The next spin is still 18/37 to land on red.
2. Martingale Betting Systems
   • The Fibonacci system is a variation of the Martingale system, where instead of doubling your bet after each loss, you follow the Fibonacci sequence. This is an arbitrary choice to make people think there is some sophistication to the gambling degeneracy and it does not change the underlying mathematics of the situation in the slightest. The problem with these systems is that they assume infinite capital and no table betting limits, which is not how casinos like to operate in reality.
   • Yes, Martingale works, if you have infinite money and if the casino allowed you to gamble trillions on a table. If the first were true, you wouldn’t be at the roulette table in the first place. If the second were true , casinos would go bankrupt in a week, which is why they don’t allow it.

The Youtuber seems aware of this:

“Note that ideally because of table limits, you need to avoid 12 losses. If you go to 15 spins, you’re kinda in trouble”

def fibonacci(n: int) -> int:
    if n < 0:
        raise ValueError("Index must be non-negative.")
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def get_column_of_number(number, columns):
    if number == 0:
        return None  # 0 is not in any column
    for col, nums in columns.items():
        if number in nums:
            return col
    raise ValueError("Invalid roulette number.")

To give this strategy the benefit of the doubt, let’s startr simulating without a table limit:

• 10k start capital
• Start with 5 CHF bet

roulette = SwissRoulette(seed=69)

initial_capital = 10_000
initial_bet_size = 5

capital = initial_capital
current_bet_size = initial_bet_size

simulations = 100_000

consecutive_loss_counter = 0

bet_sizes = []
wins = []
capital_path = []

for s in range(simulations):

    # Spin the wheel with given bet size
    result = roulette.place_bet(
        bet_type="column",
        bet_value=1,
        stake=current_bet_size,
    )

    # Winning case: Get paid, return to initial bet size
    if result["win"]:
        capital -= current_bet_size
        capital += result["payout"]
        consecutive_loss_counter = 0
        wins.append(1)
    # Losing case: Lose stake, increase count of losses
    else:
        capital -= current_bet_size
        consecutive_loss_counter += 1
        wins.append(0)

    capital_path.append(capital)

    # Define bet size based on consecutive losses
    current_bet_size = min(
        initial_bet_size * fibonacci(consecutive_loss_counter + 1), capital
    )
    bet_sizes.append(current_bet_size)

    if capital <= 0:
        break

df = pl.DataFrame(
    {
        "betnum": range(len(capital_path)),
        "win": wins,
        "bet_size": bet_sizes,
        "capital": capital_path,
    }
)

(
    pn.ggplot(df, pn.aes("betnum", "capital"))
    + pn.geom_step()
    + pn.labs(
        title="One Run of Fibonacci Betting Strategy",
        x="Number of Bets Placed",
        y="Capital (CHF)",
    )
    + pn.scale_x_continuous(
        labels=comma_format(),
    )
    + pn.scale_y_continuous(
        labels=comma_format(),
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

And here, you’re staring into the ugly face of a Martingale strategy’s P&L and it goes like this:

It’s working… It’s working… I’ve lost my life savings.

Already from one run, it can be suspected that the player goes bust eventually. This is because the Fibonacci sequence grows very quickly and the bet sizes can become very large after a series of losses:

• Here, the player puts up over 15k on a single bet to recover a long losing streak.

(
    pn.ggplot(df, pn.aes("betnum", "bet_size"))
    + pn.geom_step()
    + pn.labs(
        title="Bet Size Over Time Using Fibonacci Betting Strategy",
        x="Number of Bets Placed",
        y="Bet Size (CHF)",
    )
    + pn.scale_x_continuous(
        labels=comma_format(),
    )
    + pn.scale_y_continuous(
        labels=comma_format(),
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

Casinos have table limits for a reason. Of course, they know about Martingale systems and they have a whole team dedicated to risk and liquidity management, so let’s see what happens if we introduce the table limit of the Casino in Interlaken:

https://casino-interlaken.ch/spiele/

For columns, there is a 600 CHF table limit. Rerun with this table limit instead:

initial_capital = 10_000
initial_bet_size = 5

table_limits = 600

capital = initial_capital
current_bet_size = initial_bet_size

simulations = 100_000

consecutive_loss_counter = 0

bet_sizes = []
wins = []
capital_path = []

roulette = SwissRoulette(seed=69)

for s in range(simulations):

    # Spin the wheel with given bet size
    result = roulette.place_bet(
        bet_type="column",
        bet_value=1,
        stake=current_bet_size,
    )

    # Winning case: Get paid, return to initial bet size
    if result["win"]:
        capital -= current_bet_size
        capital += result["payout"]
        consecutive_loss_counter = 0
        wins.append(1)
    # Losing case: Lose stake, increase count of losses
    else:
        capital -= current_bet_size
        consecutive_loss_counter += 1
        wins.append(0)

    capital_path.append(capital)

    # Define bet size based on consecutive losses
    current_bet_size = min(
        initial_bet_size * fibonacci(consecutive_loss_counter + 1),
        table_limits,
        capital,
    )
    bet_sizes.append(current_bet_size)

    if capital <= 0:
        break

df = pl.DataFrame(
    {
        "betnum": range(len(capital_path)),
        "win": wins,
        "bet_size": bet_sizes,
        "capital": capital_path,
    }
)

(
    pn.ggplot(df, pn.aes("betnum", "capital"))
    + pn.geom_step()
    + pn.labs(
        title="One Run of Fibonacci Betting Strategy with Table Limits",
        x="Number of Bets Placed",
        y="Capital (CHF)",
    )
    + pn.scale_x_continuous(
        labels=comma_format(),
    )
    + pn.scale_y_continuous(
        labels=comma_format(),
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

(
    pn.ggplot(df, pn.aes("betnum", "bet_size"))
    + pn.geom_step()
    + pn.labs(
        title="One Run of Fibonacci Betting Strategy with Table Limits",
        x="Number of Bets Placed",
        y="Bet Size (CHF)",
    )
    + pn.scale_x_continuous(
        labels=comma_format(),
    )
    + pn.scale_y_continuous(
        labels=comma_format(),
    )
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 4))
)

Now the bet size is capped at 600 CHF. This leads to the player being incapable of recovering losses after a certain point, leading to inevitable ruin.

Let’s visualise the quantiles as before.

TARGET_DIR = "C:/Users/mathi/Documents/Python/Casino Blog Post/Cruiseship Donny"
filename = "cruiseship_donny_fibonacci_dozen.csv"
roulette = SwissRoulette(seed=69)
people = 1_000
initial_capital = 50_000
initial_bet_size = 5
table_limits = 600
simulations = 100_000

people_dfs = []

for p in tqdm(range(people)):

    capital = initial_capital
    current_bet_size = initial_bet_size

    consecutive_loss_counter = 0

    bet_sizes = []
    wins = []
    capital_path = []

    for s in range(simulations):

        # Spin the wheel with given bet size
        result = roulette.place_bet(
            bet_type="column",
            bet_value=1,
            stake=current_bet_size,
        )

        # Winning case: Get paid, return to initial bet size
        if result["win"]:
            capital -= current_bet_size
            capital += result["payout"]
            consecutive_loss_counter = 0
            wins.append(1)
        # Losing case: Lose stake, increase count of losses
        else:
            capital -= current_bet_size
            consecutive_loss_counter += 1
            wins.append(0)

        capital_path.append(capital)

        # Define bet size based on consecutive losses
        current_bet_size = min(
            initial_bet_size * fibonacci(consecutive_loss_counter + 1),
            table_limits,
            capital,
        )
        bet_sizes.append(current_bet_size)

        if capital <= 0:
            current_bet_size = 0

    person_df = (
        pl.DataFrame(
            {
                "betnum": range(len(capital_path)),
                "win": wins,
                "bet_size": bet_sizes,
                "capital": capital_path,
                "person": p,
            }
        )
        # .filter((pl.col("betnum") % 10) == 0)
        .to_pandas()
    )

    person_df.to_csv(
        f"{TARGET_DIR}/{filename}",
        mode="a",
        header=not os.path.exists(f"{TARGET_DIR}/{filename}"),
        index=False,
    )

def calculate_ribbon_data(df):

    ribbon_data = (
        df.group_by("betnum")
        .agg(
            q001=pl.col("capital").quantile(0.001),
            q01=pl.col("capital").quantile(0.01),
            q10=pl.col("capital").quantile(0.1),
            q25=pl.col("capital").quantile(0.25),
            mean=pl.col("capital").mean(),
            q75=pl.col("capital").quantile(0.75),
            q90=pl.col("capital").quantile(0.9),
            q99=pl.col("capital").quantile(0.99),
            q999=pl.col("capital").quantile(0.999),
        )
        .sort("betnum")
        .collect()
    )

    ribbon_long = pl.concat(
        [
            ribbon_data.select(
                [
                    "betnum",
                    pl.col(layer["ymin_col"]).alias("lower"),
                    pl.col(layer["ymax_col"]).alias("upper"),
                    pl.lit(layer["label"]).alias("quantile_range"),
                ]
            )
            for layer in ribbon_layers
        ]
    ).with_columns(
        pl.col("quantile_range").cast(
            pl.Enum(["0.1%-99.9%", "1%-99%", "10%-90%", "25%-75% (IQR)"])
        )
    )

    mean_path = ribbon_data.select("betnum", "mean").with_columns(
        type=pl.lit("Average")
    )

    return ribbon_long, mean_path

df = pl.scan_csv(f"{TARGET_DIR}/result.csv")

ribbon_long, mean_path = calculate_ribbon_data(df)

(
    pn.ggplot()
    + pn.geom_ribbon(
        data=ribbon_long,
        mapping=pn.aes("betnum", ymin="lower", ymax="upper", fill="quantile_range"),
    )
    + pn.geom_line(
        data=mean_path,
        mapping=pn.aes("betnum", "mean", colour="type"),
        # colour="midnightblue",
    )
    + pn.scale_fill_manual(values=["#C5D5E8", "#8FADD8", "#5985C8", "#2F5D9E"])
    + pn.labs(
        title=f"""{people} Simulations of Cruise Ship Gambling's: "Fibonacci's Dozen Golden Entry" """,
        x="Bet Number",
        y="Capital Balance",
        fill="Quantiles",
        colour="",
    )
    + pn.scale_x_continuous(labels=comma_format(), breaks=np.arange(0, 110_000, 10_000))
    + pn.scale_y_continuous(labels=comma_format(), breaks=np.arange(0, 110_000, 10_000))
    + pn.geom_hline(yintercept=initial_capital, linetype="dotted")
    + pn.scale_colour_manual(values=["firebrick"])
    + THEME_ACADEMIC
    + pn.theme(panel_grid_minor=pn.element_blank())
)

As before and as expected, the EV is still negative, albeit less drastic than the previous example.

If you’re one of the lucky 1%, you’ll even make it around 100k bets before going into negative P&L territory. Whether you want to spend your time and energy on this is up to you.

The bottom line is: You will go bust, there is no way around it.

Bolder Bets “Simple and Effective Strategy”

At this point I’m getting tired of these clowns, so let’s just show the quantiles for this one:

“House-beating strategy” is:

• 25 on two dozens
• 25 on two columns

# Define strategy
roulette = SwissRoulette(69)
strategy_bets = [
    {"type": "dozen", "value": 1, "stake": 25},
    {"type": "dozen", "value": 2, "stake": 25},
    {"type": "column", "value": 2, "stake": 25},
    {"type": "column", "value": 3, "stake": 25},
]

# Simulation parameters
people = 1_000
initial_capital = 50_000
simulations = 30_000
TARGET_DIR = "C:/Users/mathi/Documents/Python/Casino Blog Post/BolderBets"

# Run simulations for multiple people
people_dfs = []

for p in tqdm(range(people)):

    capital = initial_capital
    capital_path = []
    wins = []

    for s in range(simulations):

        # Check if we have enough capital to place all bets
        total_stake = sum([x["stake"] for x in strategy_bets])

        # No further bet if bust, but keep recording last capital position
        # for correct calculation of mean
        if capital <= total_stake:
            capital_path.append(capital)
            wins.append(spin_win)
            continue

        # Spin the wheel
        result = roulette.place_multiple_bets(strategy_bets)

        # Process bet results
        spin_win = 0
        for x in result["bet_results"]:
            if x["win"]:
                capital -= x["stake"]
                capital += x["payout"]
                spin_win = 1
            else:
                capital -= x["stake"]

        capital_path.append(capital)
        wins.append(spin_win)

    person_df = pl.DataFrame(
        {
            "betnum": range(len(capital_path)),
            "win": wins,
            "capital": capital_path,
            "person": p,
        }
    ).to_pandas()

    person_df.to_csv(
        f"{TARGET_DIR}/result_simpleeffective.csv",
        mode="a",
        header=not os.path.exists(f"{TARGET_DIR}/result_simpleeffective.csv"),
        index=False,
    )

# Load and aggregate results
df = pl.scan_csv(f"{TARGET_DIR}/result_simpleeffective.csv")
ribbon_long, mean_path = calculate_ribbon_data(df)

# Create the plot
(
    pn.ggplot()
    + pn.geom_ribbon(
        data=ribbon_long,
        mapping=pn.aes("betnum", ymin="lower", ymax="upper", fill="quantile_range"),
    )
    + pn.geom_line(
        data=mean_path,
        mapping=pn.aes("betnum", "mean", colour="type"),
    )
    + pn.scale_fill_manual(values=["#C5D5E8", "#8FADD8", "#5985C8", "#2F5D9E"])
    + pn.labs(
        title=f"""{people} Simulations of BolderBets' "Simple and Effective Strategy" """,
        x="Bet Number",
        y="Capital Balance",
        fill="Quantiles",
        colour="",
    )
    + pn.scale_x_continuous(labels=comma_format(), breaks=np.arange(0, 100_000, 2_000))
    + pn.scale_y_continuous(labels=comma_format(), breaks=np.arange(0, 110_000, 10_000))
    + pn.coord_cartesian(xlim=(0, 25_000))
    + pn.geom_hline(yintercept=initial_capital, linetype="dotted")
    + pn.scale_colour_manual(values=["firebrick"])
    + THEME_ACADEMIC
    + pn.theme(panel_grid_minor=pn.element_blank())
)

Do I even need to say anything? If you’re on the same cruiseship as this guy, freeze your 401k account before walking in a 50m radius of his Roulette table.

Plinko

Having ranted about Roulette, which is often catered to adults, I want to mention a game because it does something particularly perfidious: proliferate gambling addiction among young adults and kids.

Here’s a short video about it, but I’ll explain it below as well.

In Switzerland, most of the foreign gambling platforms are outlawed, but the Swiss casinos are always quick to make a worse and clunkier copy of the same thing with even worse odds (enjoying national monopoly) see Jackpots.ch.

Board and Probabilities

Here’s the logic: You have a board of a certain size, i.e. a pyramid of points at each of which a ball can go left or right while falling down.

The first lirst level starts with two possible ways for the ball to go. Second level has 3 possible ways. Third level has 4 possible ways and so on.

The slots at the payout layer from left to right are the sum of choices at each iteration: Therefore, the probability for this is Binomial, the sum of Bernoulli random variables which can either be 0 and 1, or left and right in this case.

You can choose board size from 8 to 18 as well as Risk Level low to High, which changes the payoffs.

board_depths = np.arange(8, 17).tolist()
board_depths

[8, 9, 10, 11, 12, 13, 14, 15, 16]

Going through the pain of manually collecting all of these:

multipliers = {
    8: {
        "low": [4, 1.5, 1.2, 1, 0.5, 1, 1.2, 1.5, 4],
        "medium": [14, 2, 1.2, 0.8, 0.5, 0.8, 1.2, 2, 14],
        "high": [30, 3.3, 0.8, 0.6, 0.3, 0.6, 0.8, 3.3, 30],
    },
    9: {
        "low": [10, 1.5, 1.4, 1.3, 0.5, 0.5, 1.3, 1.4, 1.5, 10],
        "medium": [17, 3, 1.3, 1.1, 0.5, 0.5, 1.1, 1.3, 3, 17],
        "high": [50, 8.3, 0.9, 0.6, 0.3, 0.3, 0.6, 0.9, 8.3, 50],
    },
    10: {
        "low": [2, 1.4, 1.3, 1.2, 1, 0.5, 1, 1.2, 1.3, 1.4, 2],
        "medium": [16, 5.2, 1.3, 1.2, 0.8, 0.5, 0.8, 1.2, 1.3, 5.2, 16],
        "high": [56, 11, 1.2, 0.9, 0.6, 0.3, 0.6, 0.9, 1.2, 11, 56],
    },
    11: {
        "low": [9, 5, 1.4, 1.3, 1.2, 0.5, 0.5, 1.2, 1.3, 1.4, 5, 9],
        "medium": [26, 10, 1.6, 1.2, 1, 0.5, 0.5, 1, 1.2, 1.6, 10, 26],
        "high": [146, 22, 2, 0.9, 0.6, 0.3, 0.3, 0.6, 0.9, 2, 22, 146],
    },
    12: {
        "low": [13, 3, 1.3, 1.2, 1.1, 1, 0.5, 1, 1.1, 1.2, 1.3, 3, 13],
        "medium": [45, 8, 4, 1.1, 1, 0.8, 0.5, 0.8, 1, 1.1, 4, 8, 45],
        "high": [152, 23, 5, 0.9, 0.8, 0.6, 0.3, 0.6, 0.8, 0.9, 5, 23, 152],
    },
    13: {
        "low": [15, 5, 2.5, 1.6, 1.3, 1.1, 0.5, 0.5, 1.1, 1.3, 1.6, 2.5, 5, 15],
        "medium": [38, 20, 4, 2, 1.3, 0.8, 0.5, 0.5, 0.8, 1.3, 2, 4, 20, 38],
        "high": [180, 48, 13, 0.9, 0.8, 0.6, 0.3, 0.3, 0.6, 0.8, 0.9, 13, 45, 180],
    },
    14: {
        "low": [
            10,
            1.5,
            1.4,
            1.3,
            1.2,
            1.1,
            1,
            0.5,
            1,
            1.1,
            1.2,
            1.3,
            1.4,
            1.5,
            10,
        ],
        "medium": [40, 16, 5, 2, 1.3, 1, 0.8, 0.5, 0.8, 1, 1.3, 2, 5, 16, 40],
        "high": [200, 30, 6, 3, 1.5, 0.9, 0.6, 0.3, 0.6, 0.9, 1.5, 3, 6, 30, 200],
    },
    15: {
        "low": [20, 8, 3, 2, 1.5, 1.2, 1.1, 0.5, 0.5, 1.1, 1.2, 1.5, 2, 3, 8, 20],
        "medium": [
            60,
            32,
            10,
            4,
            1.5,
            1.1,
            0.8,
            0.5,
            0.5,
            0.8,
            1.1,
            1.5,
            4,
            10,
            32,
            60,
        ],
        "high": [
            360,
            62,
            30,
            6,
            0.9,
            0.8,
            0.6,
            0.3,
            0.3,
            0.6,
            0.8,
            0.9,
            6,
            30,
            62,
            360,
        ],
    },
    16: {
        "low": [
            20,
            2,
            1.8,
            1.6,
            1.5,
            1.2,
            1.1,
            0.9,
            0.5,
            0.9,
            1.1,
            1.2,
            1.5,
            1.6,
            1.8,
            2,
            20,
        ],
        "medium": [
            50,
            30,
            8,
            2.2,
            1.6,
            1.2,
            1.1,
            0.8,
            0.5,
            0.8,
            1.1,
            1.2,
            1.6,
            2.2,
            8,
            30,
            50,
        ],
        "high": [
            1500,
            160,
            40,
            5.5,
            0.9,
            0.8,
            0.7,
            0.6,
            0.3,
            0.6,
            0.7,
            0.8,
            0.9,
            5.5,
            40,
            160,
            1500,
        ],
    },
}

# Check the correct board lengths
for d in board_depths:
    for risk in ["low", "medium", "high"]:
        len(multipliers[d][risk]) == (d + 1), "Incorrect payout length"

Additionally, you can select the bet size of each of the balls that is sent through the Plinko board.

bet_sizes = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200]

Closed Form Expected Value

Because we are dealing with a Binomial distribution, calculation of EV is straight-forward in closed form.

Also, this post is getting very long, so let’s just show the asymptotic truth without having simulations approximate it.

from scipy.stats import binom

For each of the risk levels and board size combinations, I’ll calculate the EV by multiplying the probabilities of the outcomes with their respective payoffs:

results = []

for depth in board_depths:
    probs = []
    for successes in range(depth + 1):
        probs.append(binom.pmf(k=successes, n=depth, p=0.5))

    for risk in ["low", "medium", "high"]:

        ev = np.matmul(np.array(probs), np.array(multipliers[depth][risk]))

        results.append(pl.DataFrame({"board_depth": depth, "risk": risk, "ev": ev}))

(
    pn.ggplot(
        pl.concat(results, how="vertical_relaxed"),
        pn.aes("board_depth", "ev"),
    )
    + pn.labs(
        title="Expected Value of Different Board Depths and Risk Levels",
        x="Board Depth",
        y="Expected Value (CHF)",
        colour="Risk Level",
    )
    + pn.geom_point(pn.aes(colour="risk"))
    + pn.expand_limits(y=1)
    + THEME_ACADEMIC
    + pn.theme(figure_size=(6, 3))
)

Three things become visible:

1. None of them have positive EV for betting 1 CHF (all below 1 CHF) - of course.
2. Medium risk profile is far better than the other two (what’s the logic behind this? Probably getting people hooked on the standard setting and then taking away even more when they are getting desperate and play with the settings).
3. The American version of Plinko famously has 1% house edge. The Swiss version has much higher margins of up to 4%, which is suprising given the frontend looks like a 2003 slot machine running on 16kb RAM. Where is this free money going?

With this, I’ll close here. Don’t play this game… Or any game a casino offers you for that matter.