Elliott Wave, from theory to trade.

Everything else in Elliott is a guideline. These three are rules — if price breaks one, your count is wrong and you must recount. This is what makes wave analysis falsifiable (and therefore tradeable: every rule is a natural stop level).

• Rule 1: Wave 2 can retrace 99.9% of wave 1, but never all of it. Trading use: a long at the wave-2 low has a natural, structural stop just below the wave-1 start.
• Rule 2: Wave 3 is never the shortest motive wave — in indices it is usually the longest and steepest, driven by the "recognition" phase of the crowd. Trading use: if your "wave 3" is already shorter than wave 1 as it approaches wave 1's length, expect failure/truncation and tighten up.
• Rule 3: Wave 4 stays above wave 1's high (in an uptrend). Trading use: the top of wave 1 is the invalidation line for any wave-4 pullback entry.

Counting waves after the fact is easy; the edge comes from recognising the character of the wave you're inside right now. Volume and momentum (RSI/MACD) signatures are the data-science hook here — each wave has a measurable fingerprint.

Every wave subdivides: motive waves (1, 3, 5, A, C when impulsive) break into five smaller waves; corrective waves (2, 4, B) break into three (or a triangle/combination). A complete 8-wave cycle at one degree is just two bars of the pattern one degree higher.

Degree labels (you only need three at once — the one you trade, one above for context, one below for timing):

The standard impulse is the 5-wave structure from Fig 1, obeying all three rules. In real markets one of the three motive waves usually extends — it subdivides visibly and runs far beyond normal projections. In stock indices the extension is most often wave 3; in commodities (Gold, Oil, Silver) wave 5 extensions are common — a crucial market-personality difference.

• If wave 3 extends: wave 5 tends toward equality with wave 1 — a precise, tradeable target.
• If waves 1 and 3 are roughly equal: expect the wave-5 extension — don't fade the "overextended" move early (the Gold trap).
• Fifth-wave failure (truncation): wave 5 fails to exceed wave 3's high — rare, but it signals violent reversal; most common after an already-extended wave 3.

Diagonals are 5-wave structures squeezed between converging trendlines where wave 4 is allowed to overlap wave 1 (the only motive structure where rule 3 relaxes). Sub-waves are usually threes (3-3-3-3-3).

Zigzags are the correction you want to see when trend-following: fast, deep, terrifying, and finished quickly. The C-leg completion zone (C=A overlapping a 50–61.8% retracement of the prior impulse) is the highest-quality pullback entry Elliott offers — it is exactly the fib-cluster logic of combination C6.

Why flats matter to day traders: the expanded flat is the Elliott name for the classic failed breakout → full reversal sequence. Price breaks the prior high (wave B — everyone buys the breakout), then reverses through the whole range (wave C — trapping them all). If you've internalised this one structure, you'll stop buying late breakouts and start anticipating the C-wave fade level at 1.618×A. Flats usually occupy wave 4 positions and B-waves — slow, overlapping, range-day material.

A triangle in wave-4 position is the market saying "one more push, then done": the post-triangle thrust is typically the final wave of the sequence. This means: trade the thrust, but take profit at the measured target and don't hang around — the whole trend often reverses after it. Lunchtime index coils that break in the afternoon are usually exactly this structure.

Corrections can chain: two (or three) simple corrections joined by an X-wave — labelled W-X-Y (double three) or W-X-Y-X-Z (triple three). You rarely need to label these precisely intraday. What you need is the practical takeaway: if a correction looks finished but is "too small in time" versus the wave it corrects, expect another leg.

• Alternation in practice: deep 61.8% zigzag wave 2 → expect a shallow 23.6–38.2% flat/triangle wave 4 (and plan the smaller pullback entry accordingly).
• Time symmetry: corrections tend to consume time proportional to the wave they correct. A 2-hour impulse corrected in 10 minutes probably isn't done.
• X-waves are noise: when a correction turns into W-X-Y chop, stand aside and let the structure complete — this is ADX-below-20 territory.

The three-timeframe routine

1. H1: where are we in the Minor structure? (Which leg is today likely to be — a 3, a 4, a C?) This sets the day's bias and the "surprise direction".
2. 15m: count the Minute waves of the current leg. Mark the fib zones (W2 / W4 pullbacks, C=A completions) as horizontal zones on your chart before the session.
3. 5m: don't count — trigger. When price enters a pre-marked zone, use the entry logic from the combinations (trigger candle + RSI/volume confirmation).

Market-specific wave tendencies

All wave counting starts from swing pivots. Doing this by eye invites bias; a ZigZag algorithm with a fixed reversal threshold (in ATR units, not percent — so it adapts per market) makes pivots reproducible. This is the same logic behind TradingView's built-in ZigZag indicator and its Elliott Wave auto-detection.

# Objective swing detection: ATR-scaled ZigZag pivots (pandas)
import pandas as pd

def zigzag_pivots(df: pd.DataFrame, atr_mult: float = 2.0) -> pd.DataFrame:
    """Return swing pivots where price reversed >= atr_mult * ATR(14).
    df columns: high, low, close. Output: index, price, kind ('H'/'L')."""
    tr = pd.concat([(df.high - df.low),
                    (df.high - df.close.shift()).abs(),
                    (df.low  - df.close.shift()).abs()], axis=1).max(axis=1)
    atr = tr.rolling(14).mean()
    pivots, direction = [], 0   # 0 unknown, +1 seeking high, -1 seeking low
    ext_i = df.index[0]; ext_p = df.close.iloc[0]
    for i, row in df.iterrows():
        if direction >= 0 and row.high > ext_p: ext_i, ext_p = i, row.high
        if direction <= 0 and row.low  < ext_p and direction != 0: ext_i, ext_p = i, row.low
        thresh = atr_mult * atr.loc[i] if pd.notna(atr.loc[i]) else None
        if thresh is None: continue
        if direction >= 0 and ext_p - row.low >= thresh:      # confirmed high
            pivots.append((ext_i, ext_p, 'H')); direction = -1; ext_i, ext_p = i, row.low
        elif direction <= 0 and row.high - ext_p >= thresh:   # confirmed low
            pivots.append((ext_i, ext_p, 'L')); direction = +1; ext_i, ext_p = i, row.high
    return pd.DataFrame(pivots, columns=['time', 'price', 'kind'])

With pivots in hand, a candidate 5-wave impulse is just six consecutive pivots — and the three Elliott rules become boolean checks:

def is_valid_impulse(p: list[float]) -> bool:
    """p = [start, w1, w2, w3, w4, w5] pivot prices for an up-count."""
    w1, w3, w5 = p[1]-p[0], p[3]-p[2], p[5]-p[4]
    rule1 = p[2] > p[0]              # W2 holds above start
    rule2 = not (w3 < w1 and w3 < w5)  # W3 not shortest
    rule3 = p[4] > p[1]              # W4 above W1 high
    return rule1 and rule2 and rule3

The "wave 2 retraces 61.8%" guideline is a claim about a distribution. Before trusting it with money, measure it: for every algorithmically-detected impulse, compute the actual retracement and projection ratios and histogram them per market.

# Ratio harvest over detected impulses → per-market distributions
ratios = []
for p in valid_impulses:                       # sextets from step 1
    w1 = p[1] - p[0]
    ratios.append({
        'w2_retr': (p[1] - p[2]) / w1,
        'w3_ext' : (p[3] - p[2]) / w1,
        'w4_retr': (p[3] - p[4]) / (p[3] - p[2]),
        'w5_vs_w1': (p[5] - p[4]) / w1,
    })
df_r = pd.DataFrame(ratios)
print(df_r.describe(percentiles=[.25, .5, .75]))   # medians vs textbook ratios

What to do with the result:

• If US500's median w2_retr is 0.58 with interquartile range 0.45–0.68, then "buy the 50–61.8% zone" is validated for that market — and you also know how often it fails (the >0.80 tail is your stop-out rate estimate).
• Compare markets: expect Gold/Silver to show fatter w5_vs_w1 tails (wave-5 extensions) and UK100 to show more sub-threshold noise (fewer clean impulses per month).
• Log every live wave-based trade with its ratio context in JSONL — after 100 trades you can answer "do my C=A fades outperform my W2 entries?" with data instead of memory.

Wave context as ML features

You don't need a neural network to "see" waves — you need wave-derived features feeding whatever decision process you already run:

• swing_ratio — last swing length ÷ previous swing length (captures impulse vs correction character);
• overlap_frac — fraction of recent swing ranges overlapping (diagonals/corrections score high, impulses low);
• retr_depth — current pullback depth vs last impulse (the W2/W4 zone detector);
• div_flag — price extreme with RSI non-confirmation (the wave-5 signature from the personality table);
• time_sym — correction duration ÷ impulse duration (flags "too fast to be done" corrections).

A gradient-boosted classifier on those five features, labelling "did price extend ≥1R in trend direction within N bars", is a legitimate research project — and even if you never deploy it, its feature importances tell you which Elliott concepts carry real signal on your market.

Backtest hygiene (where wave systems usually cheat)

• Pivot look-ahead: a ZigZag pivot is only confirmed after the reversal threshold is hit — bars later. Backtests that enter "at the wave-2 low" using pivots known only in hindsight are fiction. Always lag entries to pivot-confirmation time.
• Count survivorship: in hindsight you keep the count that worked. Live, log all valid candidate counts and trade only rule-based selections.
• Regime split: validate separately on trend and range months (ADX-filtered) — wave entries behave completely differently across regimes.
• Costs: CFD spreads on Silver and WTI are large relative to 5m structures; a strategy profitable on mid prices can die on spread alone. Model it.