Triangular Martingale

Size follows the triangular numbers — 1, 3, 6, 10, 15 — so each level adds one more unit than the level before it. It is routinely mistaken for a moderate curve because it is not exponential, but the cumulative capital grows roughly with the cube of depth, which makes it one of the most expensive curves in the catalog at any realistic depth.

Size at level i is i(i+1)/2. The per-level increment itself grows linearly, so the ladder total grows cubically. Ten levels are already an order of magnitude more expensive than linear martingale.

Below is the wizard's own ladder table and the trading terminal's chart engine, both driven by buildLadderPlan for this mode. Change the level count, spread or target and the rung prices, sizes, capital ramp and chart lines recompute exactly as they would in the grid designer.

Cumulative cost grows approximately as n³/6. Every added level is dramatically more expensive than the last, so depth must be chosen from the capital table rather than from a coverage target.

Read the cost vs 5 levels column as the escalation test. A flat ladder doubles when the depth doubles; anything materially above that is a curve whose coverage has to be bought rather than simply configured.

With every rung filled, the volume-weighted average entry is 92.25 against a base of 100 and a deepest rung of 90.00 — so the average sits 78% of the way down the covered range. Getting back to flat from the bottom therefore needs a 2.50% bounce, against 5.00% for a flat ladder of the same depth — 2.50% less work.

Size equals the i-th triangular number (1, 3, 6, 10, 15…). Cumulative capital grows roughly with n³, so it escalates faster than most people expect from a polynomial mode.

The last row is the metric that separates modes. Profit for a full cycle is the target percentage of deployed capital in every mode, so it cannot discriminate. What differs is how much capital has to sit reserved to earn one shallow cycle: this mode reserves 220× base to collect 0.5 bps of it when the first rung completes.

High-conviction snap-back reversals with a hard level cap, actively supervised. There is no regime where a cubic capital ramp is a sensible default.

Size equals the i-th triangular number (1, 3, 6, 10, 15, …). Aggressive: grows faster than quadratic-cumulative, so recovery is quick but capital demand escalates sharply.

Convex and easy to underestimate. The specific danger is category error: operators file it mentally next to "polynomial, therefore moderate" when its cost profile is closer to Fibonacci and geometric.

This is the product's grid backtester, not a summary of one. It fetches public candles for the instrument you pick, rebuilds the ladder anchored on the first candle of the window, then applies the engine's own fill, take-profit, refill and stop-loss rules bar by bar. The caveat block inside the panel is part of the output — read it before trusting a number.

First the arithmetic, then the market. The table below is computed from the size curves alone; the sweep underneath replays every one of those ladders over the same real candle window, with grid_mode as the only variable.

• High-conviction snap-back reversals with a hard level cap and active supervision.
• You have measured the requirement in the backtester and funded it explicitly.

• Anything unattended.
• Deep ladders — the cost is punitive past about ten levels.
• Any account where the full ladder is not comfortably fundable.

• Depth is the only meaningful dial, and it should be small. If you want this shape with a ceiling, use capped martingale.
• Power mode with p between 1.5 and 2 gives a similar family of shapes with a continuous control instead of a fixed sequence.

• Alert early on depth: by the time half the ladder has filled, the remaining half costs several times as much as everything spent so far.
• Watch the deepest filled level, not the P&L. Depth is the leading indicator; P&L is the lagging one.
• Compare peak committed notional against the account, weekly. A growth curve that has never been deep has never been tested.
• Treat every level increase as a capital decision: adding levels to a growth curve is not a linear cost.

1. 1
   Cubic surprise

   Depth increases approved as incremental turn out to multiply the requirement. Always re-read the capital table.
2. 2
   Funding wall

   As with exponential, a rejected deep order stops the averaging exactly when it was supposed to matter.

• Spread sets how fast the ladder consumes depth. Widening it buys coverage for the same level count at the cost of fewer fills.
• Target sets what each cycle books. Below round-trip fees plus slippage, a grid is a fee generator regardless of the size curve.
• The stop loss is the only bound on the tail. Without it, the curve's worst case is whatever the market does, not what you planned.

1. 1
   Where does the shape come from?

   It is the running sum of a linear increment — the same sequence as the cumulative cost of linear martingale, used here as the per-level size. That is precisely why the totals become cubic.

• Sizes and capital: levelMultiplier / gridModeCurve in lib/grid/gridModes.ts, mirrored from grid_modes.hpp and the Python engine's lot calculator.
• Rung and exit prices, capital ramp, init targets and the stop line: buildLadderPlan — the same builder the wizard and grid designer use.
• Backtest fills, cycles and P&L: runBacktest / runBacktestSweep over public broker candles, applying the engine's fill, exit, refill and stop rules.
• Price charts: the trading terminal's chart engine, with the ladder drawn through its own price-line API.

• 1.Grid Modes — Overview — The full taxonomy and how to choose
• 2.Martingale family — What every curve in this family has in common
• 3.Capital Allocation — Sizing an account to a Triangular Martingale ladder
• 4.Stop Loss — Bounding this curve's tail
• 5.Reading the Ladder Plan — Verifying the curve before deploying
• 6.Grid Structure — Levels, init batch and base size