Does the Labouchère system work?

How Labouchère is played

1. Write the line 1, 2, 3, 4 (10 units, the cycle's profit goal).
2. Stake the first number plus the last number, in units.
3. On a win, cross off both numbers. On a loss, add the lost stake to the end of the line.
4. When the line is empty, the cycle has won 10 units; start a new line.

What 20,000 sessions show

Sessions that finished ahead were up $200 on average; sessions that finished behind were down $848.39. 23.8% of sessions ended because the next stake no longer fit the bankroll or the table limit.

Each win removes two numbers and each loss adds only one, so the line can be cleared while losing more spins than it wins. The catch is in the size of what gets added: after a run of losses the first-plus-last stake grows quickly, and the line can reach the table limit long before it empties.

The median session lasted 28 spins. The median longest losing run was 4 spins in a row (the worst of 20,000 was 16), and one session in ten put at least $290 on the table in a single spin.

European versus American wheel

The same 20,000 seeds, replayed on a double-zero wheel. The second zero roughly doubles the edge to $5.26 per $100 wagered. Measured return goes from −$2.69 to −$5.11 per $100, and the mean session from −$50 to −$100.

The code that produced these numbers

This Lua is the strategy as Engineer mode runs it, inside the same sandbox and kernel. A test in the repository replays it against the bulk generator on fixed seeds and fails the build if the two ever disagree by a single dollar.

-- Labouchère: bet the sum of the first and last numbers on a list; cross them off on a win, append the stake on a loss.
-- Session rules shared by every 0xroulette.com/systems page:
-- $5 unit, $500 table max, walk away at +$200, and stop the moment
-- the next stake can't be covered by the bankroll or the table limit.
local UNIT, TABLE_MAX, TARGET = 5, 500, 200

local line

local function reset() line = { 1, 2, 3, 4 } end

local function stake_units()
  if #line == 1 then return line[1] end
  return line[1] + line[#line]
end

local function place(ctx)
  return { { type = "red", amount = UNIT * stake_units() } }
end

local function settle(result)
  local units = stake_units()
  if result.net > 0 then
    table.remove(line, 1)
    table.remove(line)
  else
    table.insert(line, units)
  end
  if #line == 0 then reset() end
end

-- Shared wrapper: enforces the session rules around place/settle.
strategy = {}
local start, stopped

function strategy.setup(ctx)
  start, stopped = ctx.bankroll, false
  reset()
end

function strategy.bet(ctx)
  if stopped or ctx.bankroll >= start + TARGET then
    stopped = true
    return {}
  end
  local bets, stake = place(ctx), 0
  for _, b in ipairs(bets) do
    if b.amount > TABLE_MAX then stopped = true end
    stake = stake + b.amount
  end
  if stake > ctx.bankroll then stopped = true end
  if stopped then return {} end
  return bets
end

function strategy.on_spin(ctx, result)
  if not stopped then settle(result) end
end

Session rules

Limitations

One bankroll, one unit size, one table limit, and one walk-away target. A bigger bankroll or a higher limit moves where a progression breaks; it does not change the return per dollar wagered. Spins are fair and independent, as on a correctly functioning wheel or a certified RNG. Physical wheel bias is a separate question, covered on Physics.

Related

• Does the Reverse Labouchère system work?
• Does the Martingale system work?
• Does the Fibonacci roulette system work?
• All 20 systems, compared on the same seeds