The Mathematics Behind Casino Profitability: Expected Value, House Edge, Variance, and Risk of Ruin

Abstract

Casino gambling is not an entertainment economy built on chance — it is a formally structured stochastic system in which games carry asymmetric expected value, finite-sample volatility, and capital constraints. Using European roulette as the primary model, this paper derives the house advantage from first principles, proves the finite-horizon gambler’s ruin formula, and separates negative expected value from short-term randomness. A reproducible Monte Carlo simulation compares theoretical expectation, observed results, and finite-bankroll ruin probabilities. Poisson and compound Poisson models are also evaluated for rare events such as jackpots and extreme payout clusters, with attention to where those assumptions hold and where they break down. Casino profit is not produced by certainty in any individual trial. It is produced by repeated exposure to a mathematically favorable distribution under sufficient volume, liquidity, and controlled variance.

1. Introduction

The casino floor looks like disorder: roulette balls settle unpredictably, cards shuffle, dice tumble, slot reels stop in sequences no player can forecast. Mathematically, it is a collection of repeated random experiments with carefully priced payoff structures. The casino does not need to predict the next outcome. It needs only to offer wagers whose expected value is negative for the player and positive for the house.

The central distinction runs between theoretical win — the expected value implied by the rules and wagering volume — and actual win — the realized financial result after finite-sample variance. That gap narrows as volume grows: theoretical win scales linearly with total handle, while relative volatility declines as the number of independent or weakly dependent trials increases.

The literature on gambling mathematics is extensive. Ethier’s The Doctrine of Chances provides a modern probability-theoretic treatment covering house advantage, gambler’s ruin, martingales, Markov chains, and specific games including roulette, craps, baccarat, video poker, and blackjack (Ethier, 2010). Feller’s An Introduction to Probability Theory and Its Applications provides the random-walk and ruin-theory foundation (Feller, 1968). Kelly’s capital-growth criterion remains foundational for bankroll growth under favorable odds (Kelly, 1956). More recent work has examined Poisson-based modeling for casino bankruptcy risk and extreme cash-flow exposure (Siu, Chan, and Im, 2023).

2. Formal Model of a House-Banked Wager

Let ((\Omega, \mathcal{F}, P)) be a probability space representing all possible outcomes of a casino wager. Let (X) be the player’s net result from a single wager of size (w > 0). A positive value of (X) denotes a player win; a negative value denotes a player loss.

If the wager has possible net outcomes

[ x_1, x_2, \ldots, x_n ]

with probabilities

[ p_1, p_2, \ldots, p_n, \qquad p_i \geq 0, \qquad \sum_{i=1}^{n} p_i = 1, ]

then the player’s expected value is

[ E[X] = \sum_{i=1}^{n} p_i x_i. ]

The casino’s net result from the same wager is (Y = -X), so (E[Y] = -E[X]).

A house-banked game has a mathematical house advantage when (E[X] < 0), implying (E[Y] > 0). The house edge (h) is the casino’s expected profit per unit wagered:

[ h = \frac{E[Y]}{w} = -\frac{E[X]}{w}. ]

If a player wagers total handle (H), the theoretical casino win is

[ \text{Theoretical Win} = hH. ]

The house edge applies to total wagered volume, not merely the player’s initial bankroll. A player who brings 100 units to the table but cycles 1,000 units through repeated betting generates expected loss based on 1,000 units of handle.

3. Theorem 1: House Edge as Negative Player Expectation

Theorem

For any house-banked wager of stake (w > 0), if the player’s expected net return is (E[X] < 0), then the casino’s house edge is

[ h = -\frac{E[X]}{w}. ]

Proof

Let (X) denote the player’s net result. Since the game is house-banked, the casino’s net result is (Y = -X). By linearity of expectation, (E[Y] = E[-X] = -E[X]).

The house edge is defined as expected casino profit divided by amount wagered:

[ h = \frac{E[Y]}{w}. ]

Substituting (E[Y] = -E[X]):

[ h = -\frac{E[X]}{w}. ]

Since (w > 0) and (E[X] < 0), it follows that (h > 0). A negative expected value for the player is mathematically equivalent to a positive house edge for the casino. (\square)

4. European Roulette: Expected Value, Variance, and House Edge

A standard European roulette wheel has 37 pockets: numbers 1 through 36 and a single zero, with 18 red and 18 black. Consider a 10-unit wager on red. The bet pays even money if red occurs and loses if black or zero occurs.

[ P(\text{win}) = \frac{18}{37}, \qquad P(\text{loss}) = \frac{19}{37}. ]

The net outcome (X) is

[ X = \begin{cases} +10, & \text{with probability } \frac{18}{37}, \ -10, & \text{with probability } \frac{19}{37}. \end{cases} ]

Therefore,

[ E[X] = \left(\frac{18}{37}\right)(10) + \left(\frac{19}{37}\right)(-10) = -\frac{10}{37} \approx -0.27027. ]

The player loses approximately 0.27027 units per 10-unit wager in expectation. The house edge is

[ h = -\frac{E[X]}{10} = \frac{1}{37} \approx 2.7027%. ]

This does not mean the casino wins exactly 2.7027 percent every hour or every day. It means the average result converges toward this value as the number of independent trials grows.

The variance of the player’s result is (Var(X) = E[X^2] - (E[X])^2). Since both outcomes have magnitude 10,

[ E[X^2] = \left(\frac{18}{37}\right)(100) + \left(\frac{19}{37}\right)(100) = 100. ]

Thus,

[ Var(X) = 100 - \left(-\frac{10}{37}\right)^2 = 100 - \frac{100}{1369} = \frac{136800}{1369} \approx 99.927. ]

The standard deviation is (SD(X) \approx 9.996).

On a 10-unit red wager, the casino’s expected profit is about 0.27 units per bet — against a standard deviation of nearly 10 units. Volatility dominates expectation over any short run. Volume is what closes that gap.

5. Theorem 2: Theoretical Win Convergence Under Repeated Play

Theorem

Let (X_1, X_2, \ldots, X_n) be independent and identically distributed player outcomes from repeated wagers, each with finite expectation (\mu = E[X_i]) and finite variance (\sigma^2 = Var(X_i)). Let

[ S_n = \sum_{i=1}^{n} X_i. ]

Then (E[S_n] = n\mu) and (Var(S_n) = n\sigma^2). Moreover, (\frac{S_n}{n} \to \mu) as (n \to \infty) under the law of large numbers.

Proof

By linearity of expectation:

[ E[S_n] = E\left[\sum_{i=1}^{n} X_i\right] = \sum_{i=1}^{n} E[X_i] = n\mu. ]

Because the wagers are assumed independent:

[ Var(S_n) = Var\left(\sum_{i=1}^{n} X_i\right) = \sum_{i=1}^{n} Var(X_i) = n\sigma^2. ]

The standard deviation of cumulative result is therefore (SD(S_n) = \sqrt{n}\sigma).

Expected cumulative result grows linearly with (n); standard deviation grows only with (\sqrt{n}). Relative volatility shrinks as volume increases.

By the law of large numbers, (\frac{S_n}{n} \to E[X_i] = \mu). If (\mu < 0), the player’s average converges toward a loss per wager. Since the casino result is (-S_n), the casino’s average converges toward a gain per wager. (\square)

6. Theoretical Win Versus Actual Win

Casino reporting distinguishes theoretical win from actual win.

Theoretical win is the mathematical expectation implied by game rules, wager volume, and house edge:

[ \text{Theoretical Win} = Hh. ]

Actual win is the realized operating result:

[ \text{Actual Win} = \text{Amount Received} - \text{Amount Paid Out}. ]

In table games, the accounting depends on drop, chip inventory, fills, credits, markers, and jurisdictional reporting rules. In slots, actual win flows from coin-in, coin-out, jackpots, ticket activity, and progressive adjustments. The mathematical point is the same: theoretical win is expectation; actual win is one realization from a distribution.

A department can fall below theoretical win because of ordinary variance — or because of real problems: poor game protection, dealer errors, collusion, incorrect payouts, advantage play, bad rating data, excessive comps, or abnormal high-limit exposure. Mathematics does not replace investigation. It establishes the threshold for deciding when investigation is warranted.

The right management question is not “Why is actual win below theoretical?” It is “Given the game type, handle, house edge, limits, and variance, how statistically unusual is the deviation?“

7. Risk of Ruin: Formal Setup

Risk of ruin concerns a finite bankroll exposed to repeated random outcomes. Let (B_t) represent the player’s bankroll after (t) wagers. In the fixed-stake model, the player wins one betting unit with probability (p) or loses one betting unit with probability (q = 1-p):

[ B_{t+1} = \begin{cases} B_t + 1, & \text{with probability } p, \ B_t - 1, & \text{with probability } q. \end{cases} ]

The player begins with (B_0 = i), where (0 < i < T). The game stops when (B_t = 0) (ruin) or (B_t = T) (target reached). Define

[ R_i = P(\text{hit } 0 \text{ before } T \mid B_0 = i). ]

8. Theorem 3: Finite-Horizon Gambler’s Ruin Formula

Theorem

For a fixed-stake random walk with win probability (p), loss probability (q = 1-p), starting bankroll (i), lower absorbing boundary (0), and upper absorbing boundary (T), the probability of ruin before reaching (T) is:

If (p \neq q):

[ R_i = \frac{(q/p)^i - (q/p)^T}{1 - (q/p)^T}. ]

If (p = q = 1/2):

[ R_i = 1 - \frac{i}{T}. ]

Proof

(R_i) satisfies the second-order difference equation

[ R_i = pR_{i+1} + qR_{i-1}, \qquad 1 \leq i \leq T-1, ]

with boundary conditions (R_0 = 1) and (R_T = 0).

The first boundary condition states that ruin has already occurred if the bankroll is zero. The second states that ruin before the target is impossible if the target has already been reached.

For (p \neq q), seek a solution of the form (R_i = A + B(q/p)^i). Let (r = q/p), so (R_i = A + Br^i).

Applying (R_0 = 1): (A + B = 1). Applying (R_T = 0): (A + Br^T = 0).

From the first equation, (A = 1 - B). Substituting into the second:

[ 1 - B + Br^T = 0 \implies B = \frac{1}{1-r^T}, \quad A = \frac{-r^T}{1-r^T}. ]

Therefore,

[ R_i = \frac{-r^T}{1-r^T} + \frac{r^i}{1-r^T} = \frac{r^i - r^T}{1 - r^T} = \frac{(q/p)^i - (q/p)^T}{1-(q/p)^T}. ]

For the fair case (p = q = 1/2), the difference equation implies (R_i) is linear in (i). Applying (R_0 = 1) and (R_T = 0) gives

[ R_i = 1 - \frac{i}{T}. \qquad (\square) ]

9. Important Correction: Infinite-Horizon Negative-EV Play

The exponential formula [(q/p)^B] is frequently misapplied to negative-expectation games. It does not belong there.

In a negative-expectation fixed-stake game where (q > p), the random walk has negative drift. Played indefinitely with a finite bankroll and no profit target, ruin is certain:

[ P(\text{eventual ruin}) = 1. ]

The formula

[ R_B = \left(\frac{q}{p}\right)^B ]

applies in the favorable case (p > q), where positive drift makes the probability of eventual ruin less than 1. In a house-edge game, a larger bankroll may extend a session or reduce ruin probability within a finite horizon — it does not reverse the sign of the game.

10. Simulation Study: European Roulette Bankroll Ruin

Model Assumptions

• Game: European roulette, red bet
• Win probability: (p = 18/37)
• Loss probability: (q = 19/37)
• Unit stake: 10 monetary units
• Starting bankroll: 100 monetary units (10 betting units)
• Target bankroll: 200 monetary units (20 betting units)
• Sessions simulated: 200,000
• Random seed: 20260608
• Stopping rule: stop at 0 or 20 betting units

Theoretical Ruin Probability

[ R_{10} = \frac{(19/18)^{10} - (19/18)^{20}}{1 - (19/18)^{20}} \approx 0.63197. ]

A player starting with 100 monetary units and targeting 200 before going broke faces approximately a 63.2 percent ruin probability.

Monte Carlo Simulation Pseudocode

set random seed = 20260608
sessions = 200000
ruin_count = 0

for each session:
    bankroll = 10 betting units

    while bankroll > 0 and bankroll < 20:
        draw U from Uniform(0,1)

        if U < 18/37:
            bankroll = bankroll + 1
        else:
            bankroll = bankroll - 1

    if bankroll == 0:
        ruin_count = ruin_count + 1

estimated_ruin_probability = ruin_count / sessions

Simulation Results

The simulated ruin probability lands well within ordinary Monte Carlo sampling error of the theoretical value. The result makes two things concrete: a small house edge creates substantial bankroll pressure under repetition, and finite-session outcomes remain probabilistic — the player may still reach the target, but the odds are clearly against it.

11. Simulation Study: Theoretical Win Versus Actual Win

Model Assumptions

• Game: European roulette red bet
• Stake per spin: 10 monetary units
• Number of spins per trial: 10,000
• Number of trials: 10,000
• House edge: (h = 1/37)
• Theoretical casino win per 10,000 spins: (10,000 \times 10/37 = 2,702.70)

Simulation Results

Over 10,000 spins, the middle 95 percent of actual results ranged from roughly 780 to 4,660 monetary units against a theoretical win of 2,702.70. That spread does not contradict the house edge — it is what variance looks like in a finite sample.

Short-term deviations from theoretical win are not automatically evidence of poor operations, and above-theo results are not automatically evidence of superior management. Actual-versus-theoretical analysis requires a variance lens, not just a comparison of two numbers.

12. Comparative Table: EV, Variance, Theoretical Win, Actual Win, and Ruin

13. Poisson Modeling in Casino Risk

The Poisson distribution models counts of events in a fixed interval. If (N) is the number of events in a period and (\lambda) is the expected count:

[ P(N=k) = \frac{e^{-\lambda}\lambda^k}{k!}, \qquad k = 0,1,2,\ldots ]

Poisson models are useful in casino analysis when the event of interest is rare, countable, and approximately independent across small intervals. Reasonable applications include jackpot hit counts in a defined accounting period, rare side-bet payouts, unusually large progressive awards, high-denomination handpay events above a reporting threshold, and specific security or compliance events over a defined interval.

A simple Poisson model is most defensible when: events are counts rather than continuous amounts; the rate of occurrence is approximately stable over the interval; events occur independently or nearly independently; two events are unlikely to coincide in any small sub-interval; and the model targets rare-frequency exposure rather than ordinary game-by-game volatility.

14. Compound Poisson Models

For casino risk, the financial size of events usually matters more than the count. A jackpot count model alone is incomplete when jackpot values vary.

Let (N \sim \text{Poisson}(\lambda)) represent the number of rare payout events in a period, and let (Y_1, Y_2, \ldots, Y_N) represent the payout size of each. Aggregate rare-event payout is

[ S = \sum_{j=1}^{N} Y_j, ]

a compound Poisson model. For a casino estimating quarterly exposure from large progressive jackpot hits, the hit count may follow a Poisson process, but loss severity depends on jackpot meter size, denomination, participation, progressive reset value, and linked-machine configuration. The relevant risk is not merely (P(N \geq 1)) — it is the distribution of (S = Y_1 + Y_2 + \cdots + Y_N). That distribution informs liquidity needs, reserve policy, and maximum payout exposure.

15. When Poisson Modeling Is Appropriate

Poisson modeling suits event frequency, not ordinary win/loss fluctuation. It is useful for rare, discrete events where the rate can be estimated from historical observations or game mathematics.

Appropriate applications include jackpot hit counts, rare bonus-trigger counts, major payout incidents, large-value handpays, threshold-based suspicious transaction report counts, and table-game events meeting predefined abnormality criteria.

As a first approximation when data are limited, Poisson is also useful because its assumptions are explicit and the model is straightforward to interrogate.

16. When Poisson Modeling Is Not Appropriate

Poisson modeling weakens or misleads when its assumptions fail.

16.1 Non-constant rate

Casino activity varies by hour, day, season, promotion, holiday, tournament schedule, and player segment. A materially unstable event rate makes the homogeneous Poisson model inappropriate. A non-homogeneous process or segmented model fits better.

16.2 Dependence between events

Events may cluster. A promotion can simultaneously lift handle and jackpot-trigger frequency. A high-limit player can concentrate exposure. Linked progressives create dependence between jackpot size and play intensity. Independence is not a safe assumption in these settings.

16.3 Overdispersion

When observed variance exceeds the mean, the Poisson model underestimates tail risk. Negative binomial or mixed Poisson models handle this better.

16.4 Severity risk

Poisson counts events; it does not model financial severity. Casinos focused on cash-flow risk must model both frequency and payout size — via compound Poisson, simulation, or full loss-distribution modeling.

16.5 Strategic or behavioral feedback

Casino outcomes respond to player behavior, betting systems, credit limits, comps, fatigue, advantage play, dealer speed, and game protection. These factors can shift the distribution mid-observation.

16.6 Mechanical or procedural non-randomness

A biased roulette wheel, a weak shuffle, a card-exposing dealer, or a misconfigured machine can invalidate the assumed probability model. In those cases, statistical deviation may signal an operational defect rather than ordinary variance.

Poisson is a tool, not a universal solution. Use it for rare count processes under stable assumptions — not as a catch-all for casino win/loss analysis.

17. Monte Carlo Simulation as an Operational Bridge

Monte Carlo simulation is more practical than closed-form analysis for most real casino conditions. A realistic model can incorporate different bet sizes, changing player behavior, finite session length, table maximums, promotional costs, credit issuance, dealer speed, game mix, slot hold percentage, jackpot frequency, linked progressive exposure, player reinvestment of winnings, stop-loss and win-goal behavior, bankroll limits, and operator liquidity constraints.

The output is a distribution, not a single number. From it, the casino can estimate expected win, actual-win volatility, probability of daily or monthly loss, liquidity needs, jackpot reserve requirements, risk of ruin, value at risk, confidence intervals around theoretical win, and probability of extreme adverse events.

Simulation extends exact mathematics into operational conditions where closed-form formulas become too restrictive.

18. Casino-Side Risk of Ruin

Players are not the only parties exposed to bankroll risk. A casino can have positive expected value and still face short-term liquidity stress — particularly when betting limits are high relative to available capital, a small number of high-limit patrons dominate exposure, progressive jackpots are large, credit issuance is aggressive, player discounts erode effective edge, promotions create negative or low-margin exposure, actual win concentrates in volatile games such as baccarat, or capital reserves are thin.

Casino-side ruin rarely comes from ordinary low-limit, high-volume play. It comes from a mismatch between positive expectation and insufficient capital to survive the variance on the way to realizing it.

Betting limits, cage liquidity, marker control, progressive reserve policy, and game-mix management are mathematical controls — not administrative preferences.

19. Managerial Interpretation

A manager working with these tools needs to hold five distinct questions simultaneously: what is the theoretical edge of the game; how much handle was generated; what volatility is expected from this handle and game mix; how far did actual win deviate from theoretical win; and whether that deviation falls within normal sampling error or warrants operational investigation.

Skipping any of those questions leads to one of two errors. The first is overreacting to ordinary bad variance — flagging a department for procedures that are working correctly. The second is dismissing all deviations as luck, which allows real problems to accumulate: game protection failures, rating errors, dealer mistakes, advantage play, fraud, theft, collusion, or incorrect system configuration.

Mathematics does not replace judgment. It disciplines it.

20. Conclusion

Casino profitability rests on a small but persistent mathematical asymmetry. Expected value defines the direction of advantage. House edge converts that advantage into a percentage of total wagers. Variance explains why short-term actual win can diverge sharply from theoretical win. Risk of ruin explains why finite bankrolls fail before long-run expectation becomes visible.

For players, the arithmetic is unforgiving: repeated negative-expectation betting is mathematical attrition. A larger bankroll may delay ruin or improve finite-session survival odds, but it does not change the sign of the game.

The operator’s problem is more textured. A positive house edge is a statistical promise, not a daily guarantee. Casinos must manage variance, liquidity, limits, credit, progressive exposure, and rare-event severity. Theoretical win indicates where actual win should average over sufficient volume. Getting from here to there without absorbing catastrophic variance along the way is the real management problem.

The house wins not because every spin, hand, roll, or machine cycle favors it, but because the rules price repeated uncertainty in its favor — and the business is organized to expose that edge to sufficient volume while surviving the volatility between now and the long run.

Bibliography

Ethier, S. N. (2010). The Doctrine of Chances: Probabilistic Aspects of Gambling. Springer.

Feller, W. (1968). An Introduction to Probability Theory and Its Applications, Volume I (3rd ed.). Wiley.

Kelly, J. L. Jr. (1956). “A New Interpretation of Information Rate.” Bell System Technical Journal, 35(4), 917–926.

Siu, K. M., Chan, K. H., & Im, S. K. (2023). “A Study of Assessment of Casinos’ Risk of Ruin in Casino Games with Poisson Distribution.” Mathematics, 11(7), 1736.

Thorp, E. O. (1966). Beat the Dealer: A Winning Strategy for the Game of Twenty-One. Vintage.

21. Extended Simulation Study Across Casino Games

The preceding sections developed expected value, variance, theoretical win, actual win, and risk of ruin analytically. This section extends the analysis through a larger Monte Carlo study across six simplified casino-game models. The objective is to isolate relationships among house edge, volatility, bankroll depth, bet size, and finite-session ruin — not to replicate every rule variation of every game.

The six models are:

1. European roulette, even-money red bet
2. American roulette, even-money red bet
3. Craps pass line, resolved-decision model
4. Baccarat banker, 8-deck model with 5 percent commission
5. Baccarat tie, 8-deck model
6. A synthetic 95 percent RTP slot model

The roulette and craps models use exact reduced-form wager distributions. The baccarat probabilities use the standard 8-deck outcome distribution. The slot model is deliberately synthetic — a controlled high-volatility example at 95 percent RTP and 5 percent house edge, not a real machine pay table.

21.1 Game Outcome Models

All outcomes below are stated from the player’s perspective per one-unit bet.

House edge alone does not characterize a game’s risk profile. American roulette and the synthetic slot both carry roughly 5 percent house edge — but their variance structures are radically different. American roulette produces near-unit standard deviation per unit wagered. The synthetic slot exceeds 8.5 units per spin because rare large wins dominate the distribution. Same edge, completely different exposure.

22. Experiment 1: Theoretical Win Versus Actual Win Across Games

22.1 Design

Each game was simulated under:

• Stake per resolved wager: 10 monetary units
• Resolved wagers per trial: 10,000
• Number of trials: 20,000
• Random seed: 20260608
• Output measured from the casino’s perspective
• Theoretical casino win: (n \times w \times h)

22.2 Results

22.3 Interpretation

Simulated means land close to theoretical win across all six games — confirming the expected-value calculations. But that alignment of means conceals very different risk profiles.

Low-edge games like baccarat banker and craps pass line can generate casino losses over 10,000 resolved wagers with meaningful frequency. Baccarat banker was negative 12.63 percent of the time in this simulation despite its positive house edge. The tie bet carries a far higher edge and higher variance; its large margin kept casino losses extremely rare over 10,000 resolved tie bets.

The synthetic slot is the starkest case. Despite a 5 percent house edge, the casino lost money in 27.41 percent of simulated 10,000-spin trials. Rare large payouts widen the actual-result distribution enough to overwhelm the edge over finite horizons. The game is not unfavorable to the house — the math has not broken down — but the path from expected value to realized profit is volatile. Theoretical win is a mean, not a managerial guarantee. Actual win must be read through variance and confidence intervals.

23. Experiment 2: Sensitivity Analysis by Bankroll Depth

23.1 Design

This experiment estimates the probability that a player goes broke before doubling the bankroll.

Stopping conditions: (B_t \leq 0) or (B_t \geq 2B_0).

For even-money games, the exact finite-horizon gambler’s ruin formula is used. For baccarat banker, baccarat tie, and the synthetic slot, Monte Carlo simulation handles the non-symmetric outcomes.

Simulation assumptions:

• Initial bankroll expressed in betting units
• Target bankroll equals twice the initial
• Flat bet size equals one betting unit
• Monte Carlo sessions: 20,000
• Random seed: 20260608
• Method shown as “exact” where the closed-form ruin formula is used

23.2 Results

23.3 Interpretation

There is a counterintuitive result embedded in that table. For negative-expectation even-money games, the probability of ruin before doubling can increase as bankroll depth grows — when the target is scaled proportionally.

With greater distance between the two absorbing boundaries, the negative drift has more time to act. A 100-unit bankroll targeting 200 units on European roulette carries a higher ruin probability than a 10-unit bankroll targeting 20. A larger bankroll helps a player survive a fixed short session — but when the goal is to double it in a negative-expectation game, scaling both the start and the target works against the player.

The synthetic slot behaves differently. Because the model includes rare jumps of (+120) units, a larger bankroll provides more runway to survive until a large positive shock arrives. That is a volatility effect — not a player advantage. Expected value remains negative throughout.

24. Experiment 3: Sensitivity by Fixed Bankroll and Table Limit

24.1 Design

The player’s monetary bankroll is fixed at 1,000 units and the flat bet size varies. The flat bet can be read as the table maximum used by an aggressive player who always bets the maximum.

Effective bankroll depth:

[ \text{Effective Betting Units} = \frac{\text{Bankroll}}{\text{Flat Bet}}. ]

Target: double from 1,000 to 2,000 monetary units.

24.2 Results

24.3 Interpretation

For low-volatility negative-expectation games — roulette and baccarat banker — a smaller flat bet means more decisions to reach the doubling target. Since each decision carries negative expectation, more decisions extract more cumulative edge. Smaller bets, in this framing, produce a higher probability of ruin before the target is reached.

For high-volatility games, the effect reverses. In the synthetic slot model, smaller bets create more opportunities to survive until a rare large payout arrives, reducing ruin-before-doubling probability — even with negative expected value on every spin.

The casino’s takeaway runs in a different direction. Table limits and bet sizing shape volatility, liquidity exposure, game speed, and the gap between actual and theoretical win. High limits amplify short-term variance and liquidity risk. Low limits increase decision volume and pull actual win closer to theoretical. The right calibration depends on capital position, game mix, and the operator’s capacity to absorb variance on the path to expectation.

25. Methodological Limitations

The simulation is intentionally simplified, and its scope should be stated clearly.

Each game is modeled as a reduced-form outcome distribution. Real blackjack, baccarat, craps, and slot play involve rule variation, side bets, changing deck composition, player decisions, table limits, odds bets, progressive pools, and promotional effects that are absent here. The baccarat model uses fixed 8-deck probabilities without hand-by-hand card removal — adequate for a reduced-form wager model, but not for studying card composition effects, shuffle point, or advantage play. The craps pass-line model treats one resolved decision as one wager outcome, omitting roll count, odds bets, come bets, place bets, and shooter hand length. The slot model is synthetic; absent PAR-sheet replacement, it should not be described as a real pay table. All simulations assume flat betting, while real players vary bet size, chase losses, switch games, and stop. No promotional value, loyalty reward, commission discount, free play, credit rebate, or comp reinvestment is included.

These constraints define what the study answers — they do not invalidate its conclusions within that scope.

26. Research Implications

Five concrete findings emerge from the larger simulation.

Expected value is empirically visible: simulated averages converge on theoretical values across all six games. Actual win remains widely dispersed around theoretical win even after 10,000 resolved wagers — the distribution is real, not residual noise. House edge and volatility are distinct risk dimensions that must be tracked separately; two games with identical house edges can carry completely different variance profiles, producing very different actual-win distributions over finite periods. Bankroll depth and target definition must be read together — absolute size is less meaningful than the ratio of starting position to target, combined with the volatility structure of the game. And casino-side risk management must account for path risk, not just expectation; a game can be profitable long-run and still produce temporary losses, liquidity strain, or extreme payout events on the way there.

A complete casino analytics system should report theoretical win and actual win alongside variance-adjusted deviation, confidence intervals, volatility classification, bankroll exposure, and maximum-bet sensitivity.

Appendix A: Executable Methodology Code

The following Python code reproduces the simulation structure used in the study. It requires only NumPy and pandas.

import math
import numpy as np
import pandas as pd

SEED = 20260608
rng = np.random.default_rng(SEED)

# ------------------------------------------------------------
# 1. Game definitions
# Outcomes are player net results per one-unit bet.
# Probabilities must sum to 1.
# ------------------------------------------------------------

games = {
    "European roulette red": (
        np.array([1.0, -1.0]),
        np.array([18/37, 19/37])
    ),

    "American roulette red": (
        np.array([1.0, -1.0]),
        np.array([18/38, 20/38])
    ),

    "Craps pass line (resolved)": (
        np.array([1.0, -1.0]),
        np.array([244/495, 251/495])
    ),

    "Baccarat banker (8-deck)": (
        np.array([0.95, -1.0, 0.0]),
        np.array([0.458597, 0.446247, 0.095156])
    ),

    "Baccarat tie (8-deck)": (
        np.array([8.0, -1.0]),
        np.array([0.095156, 0.904844])
    ),

    "Synthetic 95% RTP slot": (
        np.array([-1.0, -0.5, 1.0, 4.0, 120.0]),
        np.array([0.80, 0.10, 0.06, 0.035, 0.005])
    ),
}

# ------------------------------------------------------------
# 2. Parameter table
# ------------------------------------------------------------

def game_parameters(games):
    rows = []

    for name, (outcomes, probs) in games.items():
        ev = float(np.sum(outcomes * probs))
        variance = float(np.sum(((outcomes - ev) ** 2) * probs))
        sd = math.sqrt(variance)

        rows.append({
            "game": name,
            "player_ev_per_unit": ev,
            "house_edge": -ev,
            "variance": variance,
            "standard_deviation": sd
        })

    return pd.DataFrame(rows)


params = game_parameters(games)
print("\nGAME PARAMETERS")
print(params)

# ------------------------------------------------------------
# 3. Experiment 1:
# Theoretical win versus actual win across repeated trials
# ------------------------------------------------------------

def volatility_experiment(
    games,
    n_bets=10_000,
    stake=10.0,
    n_trials=20_000,
    seed=SEED
):
    rng = np.random.default_rng(seed)
    rows = []

    for name, (outcomes, probs) in games.items():
        counts = rng.multinomial(n_bets, probs, size=n_trials)

        player_results = counts.dot(outcomes) * stake
        casino_results = -player_results

        player_ev_per_bet = float(np.sum(outcomes * probs)) * stake
        theoretical_casino_win = -player_ev_per_bet * n_bets

        rows.append({
            "game": name,
            "house_edge": -float(np.sum(outcomes * probs)),
            "theoretical_casino_win": theoretical_casino_win,
            "mean_simulated_casino_win": float(np.mean(casino_results)),
            "sd_actual_win": float(np.std(casino_results, ddof=1)),
            "pctl_2_5": float(np.quantile(casino_results, 0.025)),
            "median": float(np.quantile(casino_results, 0.50)),
            "pctl_97_5": float(np.quantile(casino_results, 0.975)),
            "probability_casino_loses": float(np.mean(casino_results < 0)),
        })

    return pd.DataFrame(rows)


volatility_results = volatility_experiment(games)
print("\nVOLATILITY EXPERIMENT")
print(volatility_results)

# ------------------------------------------------------------
# 4. Exact finite-horizon ruin formula for even-money games
# ------------------------------------------------------------

def exact_ruin_even_money(p, start_units, target_units):
    q = 1 - p

    if abs(p - q) < 1e-12:
        return 1 - start_units / target_units

    r = q / p

    return (r ** start_units - r ** target_units) / (1 - r ** target_units)


# ------------------------------------------------------------
# 5. Monte Carlo ruin simulation for general discrete outcomes
# ------------------------------------------------------------

def simulate_ruin(
    outcomes,
    probs,
    start_units,
    target_units=None,
    n_sessions=20_000,
    seed=SEED,
    max_steps=500_000
):
    rng = np.random.default_rng(seed)

    if target_units is None:
        target_units = 2 * start_units

    bankroll = np.full(n_sessions, float(start_units))
    active = np.ones(n_sessions, dtype=bool)
    ruined = np.zeros(n_sessions, dtype=bool)
    steps = np.zeros(n_sessions, dtype=np.int32)

    cumulative_probs = np.cumsum(probs)

    step = 0

    while active.any() and step < max_steps:
        n_active = int(np.sum(active))

        u = rng.random(n_active)
        outcome_index = np.searchsorted(cumulative_probs, u, side="right")

        bankroll[active] += outcomes[outcome_index]
        steps[active] += 1

        ruined_now = active & (bankroll <= 0)
        reached_target_now = active & (bankroll >= target_units)

        ruined[ruined_now] = True
        active = active & ~(ruined_now | reached_target_now)

        step += 1

    return {
        "ruin_probability": float(np.mean(ruined)),
        "mean_steps": float(np.mean(steps)),
        "median_steps": float(np.quantile(steps, 0.50)),
        "pctl_95_steps": float(np.quantile(steps, 0.95)),
        "unfinished_fraction": float(np.mean(active)),
    }


# ------------------------------------------------------------
# 6. Experiment 2:
# Sensitivity by bankroll depth
# ------------------------------------------------------------

def bankroll_sensitivity(games, start_units_list=(10, 25, 50, 100)):
    rows = []

    for game_index, (name, (outcomes, probs)) in enumerate(games.items()):
        is_even_money = (
            len(outcomes) == 2
            and set(np.round(outcomes, 10)) == {-1.0, 1.0}
        )

        if is_even_money:
            p_win = float(probs[np.where(outcomes == 1.0)[0][0]])
        else:
            p_win = None

        for start_units in start_units_list:
            target_units = 2 * start_units

            if is_even_money:
                ruin_prob = exact_ruin_even_money(
                    p_win,
                    start_units,
                    target_units
                )

                rows.append({
                    "game": name,
                    "bankroll_units": start_units,
                    "target_units": target_units,
                    "ruin_before_doubling": ruin_prob,
                    "mean_resolved_bets": None,
                    "method": "exact"
                })

            else:
                result = simulate_ruin(
                    outcomes,
                    probs,
                    start_units=start_units,
                    target_units=target_units,
                    n_sessions=20_000,
                    seed=SEED + game_index * 1000 + start_units
                )

                rows.append({
                    "game": name,
                    "bankroll_units": start_units,
                    "target_units": target_units,
                    "ruin_before_doubling": result["ruin_probability"],
                    "mean_resolved_bets": result["mean_steps"],
                    "method": "MC 20k"
                })

    return pd.DataFrame(rows)


bankroll_results = bankroll_sensitivity(games)
print("\nBANKROLL SENSITIVITY")
print(bankroll_results)

# ------------------------------------------------------------
# 7. Experiment 3:
# Fixed bankroll and table-limit sensitivity
# ------------------------------------------------------------

def table_limit_sensitivity(
    selected_games,
    fixed_bankroll=1000,
    target_bankroll=2000,
    flat_bets=(100, 50, 25, 10)
):
    rows = []

    for game_index, name in enumerate(selected_games):
        outcomes, probs = games[name]

        is_even_money = (
            len(outcomes) == 2
            and set(np.round(outcomes, 10)) == {-1.0, 1.0}
        )

        if is_even_money:
            p_win = float(probs[np.where(outcomes == 1.0)[0][0]])
        else:
            p_win = None

        for flat_bet in flat_bets:
            start_units = fixed_bankroll / flat_bet
            target_units = target_bankroll / flat_bet

            if start_units != int(start_units):
                raise ValueError("Bankroll must divide cleanly by flat bet.")

            start_units = int(start_units)
            target_units = int(target_units)

            if is_even_money:
                ruin_prob = exact_ruin_even_money(
                    p_win,
                    start_units,
                    target_units
                )

                rows.append({
                    "game": name,
                    "fixed_bankroll": fixed_bankroll,
                    "flat_bet": flat_bet,
                    "effective_betting_units": start_units,
                    "target_bankroll": target_bankroll,
                    "ruin_before_doubling": ruin_prob,
                    "mean_bets": None,
                    "method": "exact"
                })

            else:
                result = simulate_ruin(
                    outcomes,
                    probs,
                    start_units=start_units,
                    target_units=target_units,
                    n_sessions=20_000,
                    seed=SEED + 300000 + game_index * 1000 + start_units
                )

                rows.append({
                    "game": name,
                    "fixed_bankroll": fixed_bankroll,
                    "flat_bet": flat_bet,
                    "effective_betting_units": start_units,
                    "target_bankroll": target_bankroll,
                    "ruin_before_doubling": result["ruin_probability"],
                    "mean_bets": result["mean_steps"],
                    "method": "MC 20k"
                })

    return pd.DataFrame(rows)


selected_games = [
    "European roulette red",
    "Baccarat banker (8-deck)",
    "Synthetic 95% RTP slot"
]

table_limit_results = table_limit_sensitivity(selected_games)
print("\nTABLE LIMIT SENSITIVITY")
print(table_limit_results)

Appendix B: Additional Bibliography

Ethier, S. N. (2010). The Doctrine of Chances: Probabilistic Aspects of Gambling. Springer.

Siu, K.-M., Chan, K.-H., & Im, S.-K. (2023). “A Study of Assessment of Casinos’ Risk of Ruin in Casino Games with Poisson Distribution.” Mathematics, 11(7), 1736.

Shackleford, M. “Baccarat Basics: Eight-Deck Analysis.” Wizard of Odds.

Shackleford, M. “How the House Edge for Each Bet Is Derived: Craps.” Wizard of Odds.

Kelly, J. L. Jr. (1956). “A New Interpretation of Information Rate.” Bell System Technical Journal, 35(4), 917–926.

Feller, W. (1968). An Introduction to Probability Theory and Its Applications, Volume I (3rd ed.). Wiley.