Lot-Size Quantization & Residual Inventory Slippage Playbook

Date: 2026-03-12
Category: research
Audience: small quant execution teams running child-order schedulers across venues with discrete lot/notional constraints

Why this playbook exists

Most execution simulators optimize in continuous size space, but live venues fill in discrete units:

• round-lot or contract-size constraints,
• minimum-notional rules,
• venue-specific size increments.

That mismatch creates quantization residuals. At first they look tiny, then they accumulate near deadlines and force expensive late-stage catch-up (crossing wider spreads, paying higher markout risk, and blowing up p95 costs).

If your slippage model ignores quantity discretization, you systematically underprice tail execution risk.

Core idea

Treat size discretization as a first-class branch in execution cost, not post-trade noise.

For parent target Q, continuous child suggestion q*_k, and venue lot size L_k:

• Executed child: q_k = RoundPolicy(q*_k, L_k)
• Residual carry: r_k = r_{k-1} + (q*_k - q_k)

Total expected cost:

E[Cost] = C_base + C_quant + C_rescue

Where:

• C_base: spread/impact/delay under normal schedule,
• C_quant: discretization-induced path cost during schedule,
• C_rescue: terminal catch-up cost from accumulated residuals.

Failure mechanism (how tiny errors become expensive)

1. Continuous scheduler emits many sub-lot recommendations.
2. Rounding/down-clipping creates small underfills each interval.
3. Residual inventory drifts upward while clock time decays.
4. Urgency spikes near deadline and forces aggressive marketable flow.
5. Tail slippage increases nonlinearly (especially in thin books).

This is a convexity problem: small early quantization errors can create large late execution tax.

Cost decomposition

Cost = IS + QuantizationDriftTax + ResidualConvexityTax + TerminalMissPenalty

1) Quantization Drift Tax

Incremental cost from repeated rounding mismatch while schedule is still flexible.

2) Residual Convexity Tax

Extra cost from urgency escalation because residual remained unresolved too long.

3) Terminal Miss Penalty

Opportunity cost (or forced crossing premium) when non-zero residual hits hard deadline.

Key metrics

Quantization Pressure Ratio (QPR)

QPR_t = |r_t| / max(RemainingTarget_t, epsilon)

How much unfinished inventory is purely discretization-driven relative to remaining task.

Residual Catch-up Convexity (RCC)

RCC = d(Slippage) / d(Urgency) | high-QPR

Measures how expensive urgency becomes when residual pressure is already elevated.

Discrete Fill Friction (DFF)

DFF = Slippage_discrete - Slippage_continuous_counterfactual

Matched by volatility/spread/participation regime.

Rounding Bias Drift (RBD)

RBD = mean(sign(q*_k - q_k))

Persistent sign means systematic over- or under-rounding bias.

Lot Feasibility Stress (LFS)

LFS = Fraction(sub-lot recommendations over window)

High LFS means scheduler is operating outside feasible size grid too often.

State machine

ALIGNED

• Low QPR, low LFS
• Residual remains bounded and oscillatory

DRIFTING

• QPR rising, RBD persistent
• Begin active residual damping

CATCHUP_RISK

• High QPR + shrinking time budget
• Continuous plan no longer realistic without convex cost

DEADLINE_RESCUE

• Terminal window, residual non-trivial
• Objective shifts to controlled completion reliability

SAFE

• Protective mode when tail-cost budget breach is likely
• Hard caps and conservative rescue policy enabled

Control policy

In DRIFTING

• Enforce lot-aware projection of scheduler outputs before dispatch.
• Add residual penalty term to optimizer objective.
• Prefer venue/route combinations with finer executable increment when liquidity is acceptable.

In CATCHUP_RISK

• Increase residual-reduction priority over fee optimization.
• Temporarily reduce child count, increase feasible per-child size (to reduce repeated rounding loss).
• Use hysteresis to avoid oscillating between underfill and over-correction.

In DEADLINE_RESCUE

• Explicitly cap terminal aggression slope.
• Route by expected completion reliability, not maker rebate optics.
• If policy allows, execute controlled overfill/underfill tolerance bands with governance logging.

In SAFE

• Freeze non-essential tactic randomization.
• Activate strict residual budget and alert operator.
• Emit episode artifact for postmortem and model retraining.

Execution objective (lot-aware)

For decision a_k at step k:

J(a_k) = E[BaseCost_k] + λ1*|r_k| + λ2*TailRisk_k + λ3*TerminalRisk_k

Subject to:

• q_k is feasible on lot/notional grid,
• participation and throttle limits,
• completion deadline constraints.

This prevents infeasible “fractional optimal” schedules from leaking into live slippage.

Data contract (must-have fields)

Per child recommendation + dispatch + fill:

• target_continuous_qty, dispatched_discrete_qty, lot_size, min_notional
• rounding_policy (floor/nearest/stochastic/hybrid)
• residual_before, residual_after
• remaining_time_budget, remaining_target
• spread/imbalance/depth reliability snapshots
• urgency state, policy state transitions
• fill quality and post-fill markout horizons

Without recommendation-vs-dispatch lineage, quantization tax is invisible.

Calibration loop

Intraday (5-10 min)

• Recompute QPR/LFS/RBD regime labels.
• Update residual penalty multipliers if drift persists.

Daily

• Re-estimate DFF and RCC by venue/session bucket.
• Audit terminal rescue episodes and policy decisions.

Weekly

• Retune lot-aware scheduler weights.
• Validate q95/CVaR improvements vs completion reliability.
• Check for hidden bias from fixed rounding policy.

Practical implementation patterns

1. Stochastic rounding with bias control
   Reduces systematic drift vs hard floor rounding (with risk guardrails).

2. Residual escrow bucket
   Hold a controlled residual buffer that gets amortized earlier, not at deadline.

3. Lot-aware optimizer layer
   Project continuous plan onto feasible grid at planning time, not only at dispatch.

4. Venue increment arbitration
   Prefer finer increment venues when residual pressure is high and toxicity is acceptable.

5. Deadline-aware residual damping
   Increase residual penalty as time-to-close shrinks to avoid panic rescue.

Common failure modes

1. Continuous-only backtests
   Simulated fills are infeasible; live slippage appears as “unexpected drift.”

2. Static floor rounding
   Persistent underfill bias accumulates into terminal catch-up spikes.

3. No residual state in policy
   Router reacts only to market state, ignoring self-created inventory pressure.

4. Late rescue with no aggression cap
   Small remaining quantity still causes outsized markout/impact tails.

5. No post-trade quantization attribution
   Team cannot tell model error vs discretization mechanics.

Dashboard minimum

• QPR/LFS/RBD timeline with state overlays
• Residual trajectory vs remaining time budget
• DFF and RCC by venue/session/regime
• terminal rescue frequency and cost contribution
• q50/q95/CVaR slippage split: base vs quantization vs rescue
• completion reliability under lot-aware vs baseline policy

Practical takeaway

Discrete size constraints are not implementation detail—they are execution physics.

If you optimize in continuous space and round at the edge, residual inventory will eventually force convex late-stage slippage. Model quantization explicitly, control residual drift early, and treat deadline rescue as a governed mode, not a last-minute reflex.

One-line implementation mantra

Plan on the executable size grid from the start, or pay the rounding bill at the worst possible time.