Residual Whiteness Monitor — System Identification/Validation

Residual Whiteness Monitor

System Identification / Validation

The standard model-adequacy check, live on the canvas. Over the last N residuals it correlates the signal with a delayed copy of itself at each configured lag, and asks whether every one of those correlations is inside the confidence band a white signal would stay in:

|ρ(l)| ≤ z ÷ √N  for every configured lag l

White residuals mean the model took everything predictable out of the signal. A peak outside the band at lag l says there is structure left that a model of the right order would have captured – and the lag tells you roughly where to look.

Stateful and discrete by nature. The window advances one sample per step and has no derivative to integrate, so the block declares itself discrete-only and always steps at its own rate.

Ports

• e – the residual, a scalar [1,1]. The lags index TIME, so one block follows one residual; use one block per channel.
• white – 1 when every configured lag is inside the band, 0 when any one of them is outside. This is the verdict to gate on.
• worst – the largest correlation magnitude over the configured lags, so a diagram can show how far from white rather than only whether. What it is measured in follows Magnitude below.
• lag – the lag at which that largest magnitude occurred. It carries the configured lag value, not its position in the list: with Lags of [1; 5; 12], a peak in the third slot reports 12.

Parameters

• Window Length – N, the number of residuals the correlation is taken over. It sets the band as well as the window: the band is z ÷ √N, so a longer window is a tighter test. Keep N several times the largest lag, or the longest lags rest on a handful of products.
• Lags – the lags to test, as a vector such as [1; 2; 3]. Each is a whole number of samples from 1 to N−1. Lag 0 is rejected rather than accepted: it is the window's own energy, ρ(0) is 1 by construction, and including it would put the block permanently outside its own band.
• Band Multiplier – z, the standard-normal multiplier that sets the confidence level. 1.96 is the usual 95% band and the default; 2.576 is 99%. Raising it makes the monitor harder to trip.
• Magnitude – what the worst port reports. The verdict and the lag are the same in both; only this one output changes:
  • Coefficient – the true |ρ|, in [0, 1] and directly comparable with the band. This is the readable choice, and it costs one divide per sample.
  • Covariance – the unnormalized products averaged over N, keeping the signal's units squared. No divide anywhere, which is what keeps the three HDL targets synthesizable.
• Remove Mean – whether the window's mean is subtracted before correlating. This block defaults it to Off, unlike Autocorrelation Features, and the difference is deliberate: a residual is a model error and is zero-mean when the model is right, so subtracting the mean would hide a systematically biased model behind a "white" verdict – which is the most useful failure this block can report. Turn it On for the textbook mean-removed ACF, or when the input is a general signal rather than a residual.
• Initial Window Value – what every slot holds before the first residual arrives. The window is full from the very first step rather than growing, for the reason Rolling Statistics gives: a partial window costs a sample counter and a divide-by-count branch in all ten exported languages, for a startup transient that a validation display discards anyway.
• Epsilon – a floor on the divisor of the Coefficient magnitude, and on nothing else. The verdict never divides, so it needs no floor: see Code export below.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period. Being discrete-only, a non-positive value falls back to the model's global sampling time rather than to the surrounding rate.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The window, every lag's product sum and the comparison chain are unrolled at export time – N and the lag list are both known then – so no backend carries a loop bound, a modulo or a ring-buffer index.

The verdict never forms the ratio. |ρ(l)| ≤ k is exactly |num(l)| ≤ k·den, and den is a sum of squares and so never negative, which means the inequality survives the multiplication with no sign case-split. The comparison is therefore multiply-accumulate and nothing else. It also removes the need for an Epsilon floor on the verdict: a constant window has den = 0, where the test degenerates to |num(l)| ≤ 0 with num(l) = 0, and passes cleanly instead of dividing by zero.

The AND over the lags and the search for the worst lag are one scan, because "every lag is inside the band" is the same statement as "the largest magnitude is inside the band". No backend carries a separate reduction.

The three HDL targets split by magnitude, not by verdict: Covariance is genuine synthesizable Q16.16 throughout – multiply-accumulate, a comparison chain, and the 1/N folded into a constant at export time. Coefficient divides by the window's own energy for that one output, a signal-dependent divisor that cannot be precomputed, so that mode is emitted as simulation-only real arithmetic. Even there the verdict and the lag stay exact: both are decided before the divide and neither depends on it.

Simulink bridge

None. The System Identification Toolbox checks residual whiteness with resid – a FUNCTION that runs after a simulation over a whole logged signal and draws a correlation plot – not with a block that reports a running verdict sample by sample. Every block in this family registers Support::None for the same reason. The bridge reports the block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None. Code export verification still covers it across all ten languages.

Notes

• Stateful: the answer depends on the N−1 residuals before the current one. The window is re-seeded at the start of every run.
• No state space: the correlation is quadratic in the input, so no A/B/C/D describes it and model reduction correctly refuses the block.
• The state is read before it is written. Every lag is computed from the window as it stood, and only then does the window shift – on the three HDL targets that comes free from the registered write, and the other seven shift from the far end downwards.
• Ties go to the LOWEST lag. The scan replaces its running best only on a strictly greater magnitude, scanning the lags in written order – Argmax Decision's convention, spelled identically in all ten backends.
• The lag output is discontinuous, as any argmax is: two lags whose magnitudes are within a fixed-point quantum can rank the other way round in the three HDL targets, moving the reported lag by a whole step. That is a property of the block, not of the codegen – the same caveat Argmax Decision and Time Delay Estimator carry.
• It is a monitor, not a filter: it passes judgement on the residual and never alters it. Feed the residual on to whatever consumes it and take white as a gate.