Zweig Breadth Thrust

The hidden decision

A broad rally reading is easy to spot; proving that participation accelerated fast enough without moving the clock after the fact is the harder job.

Zweig Breadth Thrust answers one bounded question: did smoothed advancing participation accelerate from a depressed state to a broad thrust quickly enough? Its value is not a prediction. Its value is an auditable state whose inputs, time, units, and failure conditions are visible.

By the end, you will be able to calculate the method, reproduce its synthetic case, inspect its implementation trace, and decide when the output must be withheld.

Build the mental model

Convert each session's advancing share of classified issues into a 10-session EMA, arm only below 0.400, and run a visible ten-session clock until a strictly above-0.615 completion or expiry.

Unlike a one-day Advance/Decline Ratio, this detector owns smoothing, an armed state, strict inequalities, and a bounded completion clock.

The highlighted family card is a scope boundary. Count breadth, volume composition, recursive pressure, intraday sampling, and causal divergence can all produce lines, but their units and state memories are not interchangeable.

Freeze the contract before calculating

The selected formulation is:

Arm below 0.400 and complete above 0.615 within 10 later sessions. Publication invariant: The package refreshes the arming clock on each later sub-0.400 observation; equality at either threshold does not cross it.

The input table in the canonical README defines row fields and units. The parameter table distinguishes a sourced method from package choices such as equality behavior, seed, zero policy, sampling grid, normalized breadth scale, and event timestamp.

Advance-Decline Indicators supports this bounded source role: exchange breadth series have explicit universe, update-frequency, and provider lineage; issue and volume breadth must retain series identity. It does not override the limitations recorded in REFERENCES.md, and it does not establish historical performance.

Reproduce the synthetic result

Every observation below is synthetic. The arithmetic is author-derived:

The latest sub-0.400 EMA occurs on 2026-01-20. The strictly above-0.615 EMA occurs six later sessions afterward on 2026-01-28, so the event is valid and is timestamped on 2026-01-28.

The expected output is:

{
  "status": "thrust",
  "trigger_date": "2026-01-28",
  "ema": 0.664802116986
}

The SVG is not a decorative output card. It isolates the algorithm's actual learning obstacle: the final ema hides the arm, refresh, strict thresholds, and ten-session clock. Notice the labels and dashed or branched boundaries; color is supplementary.

Calculation flow

The Mermaid diagram renders from visuals/mermaid/calculation-flow.md and follows this pseudocode:

validate ordered daily count breadth
seed EMA from first advancing share
for each later session:
    update EMA
    if EMA < 0.400: arm or refresh clock
    else if armed and EMA > 0.615 and age <= 10: publish thrust now
    else if armed and age > 10: expire
return armed or no_thrust with trace

Validation comes first so bad evidence cannot mutate later state. That rule is especially important for recursive lines, timestamp grids, arming clocks, and right-side pivot confirmation.

Read the implementation

Python and TypeScript both:

1. validate finite inputs and the topic's identity/clock rules;
2. compute the named intermediate values;
3. preserve the trace needed to audit the result; and
4. return a numeric value or typed event only when the publication boundary passes.

They share datasets/canonical-fixture.json, including expected output and parameters. The code avoids provider SDKs and hidden network calls so the teaching arithmetic is fully inspectable.

Use the guided lab

Open visuals/animated/playground.html. Its objective is to step across the arm, refresh, completion, equality, and expiry boundaries.

The initial screen is the completed canonical state. Back and Step reveal one observation at a time; Play uses the same transition function; Pause stops it; Reset restores the scenario and parameter. Comparison isolates a nearby outcome, while Failure / boundary demonstrates a reason code rather than a persuasive fake value. Reduced-motion Play advances one deterministic step without starting a timer.

The diagnostic panel and audit table should be read together. A smooth chart alone cannot prove denominator topology, chronological completeness, sampling continuity, or causal confirmation.

Operational interpretation

Use the state trace to audit whether a published thrust was armed, refreshed, expired, or completed on information available that session.

Do not misuse it: Do not call a high EMA a thrust when no earlier sub-0.400 arm exists, and do not backdate the event to the arming session.

Passing the implementation checks proves definition fidelity. It does not prove reversal prediction, causal market explanation, trading profitability, transferability to another universe, or performance after costs.

Edge cases worth testing

• Exactly 0.400 does not arm; exactly 0.615 does not complete.
• A later sub-0.400 EMA refreshes the clock under this package-selected convention.
• A completion on age 10 is valid; the same crossing on age 11 is expired.
• Duplicate, decreasing, or missing session dates invalidate the state trace.

Provider corrections require recomputing the affected tail or event set. A corrected observation that becomes available later must not leak into an earlier point-in-time result.

Evidence and historical boundary

A named historical reconstruction remains deferred. Publication would require a licensed point-in-time universe, exact classification rules, synchronized observations, session and sampling policy, correction lineage, the selected calculation convention, a knowledge cutoff, and redistribution rights.

Using a famous chart without that bundle would make the story stronger and the evidence weaker. The labelled synthetic fixture is therefore the responsible public example.

Summary and handoff

You can now calculate B_t = A_t/(A_t+D_t); Z_t = EMA10(B_t), interpret ratio from 0 to 1, audit the method-specific boundary, and reproduce matching Python and TypeScript behavior. Review Advance/Decline Ratio for the immediate input concept. Continue with Cumulative TICK in the dependency path.