Cumulative TICK

The hidden decision

An intraday cumulative line can look smooth while silently jumping over a missing snapshot; the clock is part of the calculation.

Cumulative TICK answers one bounded question: what is the session-running balance of exchange issues last trading on upticks versus downticks? 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

Sample one exchange universe on an exact timezone-bearing grid, subtract downtick from uptick issues at each sample, and accumulate from a session seed.

Instantaneous TICK is one cross-section. Cumulative TICK is a path-dependent sum whose identity includes interval, grid anchor, session, universe, and reset.

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:

Sample one declared exchange universe every minute and reset the cumulative seed to zero at the regular-session open. Publication invariant: A sampling gap, session change, universe change, or non-monotone timestamp makes the cumulative tail incomplete.

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.

Glossary: TICK supports this bounded source role: tick is the number of issues on upticks minus issues on downticks at a point in the session; unchanged last trades are neutral. 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:

Every adjacent timestamp is exactly 60 seconds apart and carries an explicit UTC offset. Removing the 09:54 observation creates a 120-second gap and changes the result to incomplete / sampling_gap rather than bridging the missing sample.

The expected output is:

{
  "status": "resolved",
  "value": 1380
}

The SVG is not a decorative output card. It isolates the algorithm's actual learning obstacle: the final cumulative value hides the sampling grid and any missing snapshot. 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 positive integer interval and one session
for each timezone-bearing snapshot:
    require exact interval_seconds from the prior timestamp
    tick = uptick_issues - downtick_issues
    cumulative = cumulative + tick
return cumulative path or stop at the first grid defect

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 through an exact one-minute grid and compare a mirrored path with a genuine missing interval.

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 sampling audit to prove that every interval exists before interpreting the session-running issue-snapshot balance.

Do not misuse it: Do not bridge a missing interval, merge sessions, or compare differently sampled cumulative paths as though they were the same series.

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

• A timestamp gap that differs from interval_seconds invalidates the cumulative tail.
• A session change requires a new series and seed rather than an in-place continuation.
• Non-monotone timestamps and timezone-free strings are incomplete evidence.
• Changing the sampling interval changes the object even when the raw event stream is identical.

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 TICK_k = U_k-D_k; CTICK_k = CTICK_{k-1}+TICK_k, interpret issue-snapshots, audit the method-specific boundary, and reproduce matching Python and TypeScript behavior. Review Net Advances for the immediate input concept. Continue with Breadth-Divergence Detector in the dependency path.