A stable linear recurrence can decay to zero in exact arithmetic while a rounded implementation settles at a nonzero value or repeats a small cycle. The difference comes from the state update: rounding makes it nonlinear, so the original linear transfer function no longer describes every implemented trajectory.
The short answer is to write the quantizer and trace its update, not merely inspect the unrounded pole. This guide uses original one-state examples, proves their bounds and compares rounding with truncation. No device measurements or implementation guarantees are implied. The Z-Transform subject guide provides the linear foundation; here we examine what changes when stored states must lie on a grid.
eduKateSG · Z-Transform
Find your next learning step
Choose the question closest to your task, or follow the original worked examples in order. All teaching chapters remain open.
ROUTE 1 · CHAPTERS 1–7
Define and trace the stored state
Compare the exact recurrence with nearest-integer fixed states.
ROUTE 2 · CHAPTERS 8–14
Bound and separate the errors
Derive cycles, envelopes, physical scaling and arithmetic distinctions.
ROUTE 3 · CHAPTERS 15–21
Change the quantizer and coefficient
Test range assumptions, truncation, ties and independent transfer cases.
ROUTE 4 · CHAPTERS 22–28
Verify the implemented property
Inspect finite states, driven response, actual traces and primary sources.
ROUTE 5 · CHAPTERS 29–34
Reproduce and assess tolerance
Repair misconceptions and compare residual and trajectory-error bounds.
Chapter contents
Define and trace the stored state · Chapters 1–7
1. Begin with the unrounded recurrence
2. Define the stored-state grid
3. Trace the smallest nonzero state
4. Trace a second nonzero fixed point
5. Work a larger startup state
6. Derive the fixed-point condition
7. Classify every integer startup state for the original update
Bound and separate the errors · Chapters 8–14
8. Reverse the coefficient sign
9. Write rounding as an error term
10. Derive a deterministic magnitude envelope
11. Keep the error envelope separate from a noise spectrum
12. Restore a physical grid spacing
13. Compare rounding at each step with rounding only the display
14. Distinguish coefficient approximation from state quantization
Change the quantizer and coefficient · Chapters 15–21
15. Treat overflow and saturation as additional models
16. Compare truncation toward zero
17. Work the truncation trajectory independently
18. Examine the half-integer tie boundary
19. Derive a sufficient condition for no nonzero fixed integer state
20. Try a changed coefficient and grid
21. Check a coefficient that does converge under nearest rounding
Verify the implemented property · Chapters 22–28
22. Explain eventual periodicity with a finite state set
23. Keep zero-input behaviour separate from driven response
24. Distinguish a bounded residual from unbounded divergence
25. Test the actual stored update
26. Use independent proofs and exhaustive small tests together
Reproduce and assess tolerance · Chapters 29–34
29. Repair common misconceptions
30. Questions readers often ask
31. Reproduce the original and changed examples
32. Translate a residual tolerance into a grid requirement
33. Compare quantization error with the exact reference trajectory
CHAPTER 1 OF 34 · Define and trace the stored state
1. Begin with the unrounded recurrence
Consider the zero-input update x[n+1]=(4/5)x[n], with an arbitrary finite initial state. Its exact solution is x[n]=(4/5)^n x[0]. Because 4/5 is strictly smaller than one in magnitude, every trajectory tends to zero.
If an input u[n] is included through x[n+1]=(4/5)x[n]+u[n] and y[n]=x[n], the zero-state transfer is 1/(z−4/5), under this timing convention. The causal impulse response is absolutely summable, so the selected linear input-output map is stable.
These are statements about the exact linear equations. They do not yet describe how a computer stores each intermediate state. We will keep the coefficient 4/5 exact in the first rounded example so that state quantization is isolated from coefficient approximation, overflow and other finite-word-length effects. Changing one mechanism at a time makes the cause of the different trajectory checkable.
CHAPTER 2 OF 34 · Define and trace the stored state
2. Define the stored-state grid
Let the stored state be an integer s[n], with grid spacing one. A physical value could later be represented as Δs[n] for a positive unit size Δ, but the first calculation uses dimensionless grid units.
Define Q(v) as rounding to the nearest integer. At a half-integer tie, choose the integer of larger absolute value. Thus Q(1.5)=2 and Q(−1.5)=−2. The tie rule completes the definition even though our initial coefficient produces no ties from integer states.
The implemented zero-input update is s[n+1]=Q((4/5)s[n]). This is a new mathematical system. Its input to Q is a rational intermediate value; its stored output is on the integer grid. We assume no saturation, wraparound or overflow. Those mechanisms can create additional behaviour, but adding them silently would change the problem and invalidate some of the bounds derived below.
CHAPTER 3 OF 34 · Define and trace the stored state
3. Trace the smallest nonzero state
Start from s[0]=1. The intermediate value is 0.8, which rounds back to one. The same calculation repeats forever: s[n]=1 for every n≥0.
The unrounded trajectory from the same numerical starting value is 1,0.8,0.64,0.512,… and tends to zero. The rounded trajectory does not decay because every attempted small reduction is erased by the nearest-integer update.
This is a nonzero fixed point, not an unbounded explosion. Calling it simply unstable without defining the intended stability property can obscure the actual result. The implemented system fails to converge to zero from this initial state, while the displayed trajectory remains bounded. The distinction matters when the task concerns residual offsets, zero-input noise or convergence, rather than only whether a number exceeds every finite bound.
CHAPTER 4 OF 34 · Define and trace the stored state
4. Trace a second nonzero fixed point
Start instead from s[0]=2. The intermediate value is 1.6, which rounds to two. Hence two is another fixed point. Negative one and negative two are fixed as well because the chosen quantizer is symmetric about zero.
Zero is also fixed. The same rounded recurrence therefore has several possible long-term stored values, depending on its initial state. A zero-input test beginning exactly at zero would see only the zero trajectory and miss the other fixed points.
This is why a single reassuring simulation is insufficient for a convergence claim over all initial states. Specify the allowed startup states and test representative boundary and small-magnitude values. Our construction does not require any random noise after initialization. Deterministic rounding alone preserves the nonzero states, so an explanation based only on accumulated random disturbances would not account for this exact example.
Take s[0]=7. Successive nearest-integer updates give 7→6→5→4→3→2→2. Each arrow represents one multiplication by 4/5 followed by rounding.
The corresponding unrounded states are 7,5.6,4.48,3.584,2.8672,2.29376,… . Their decreasing magnitudes do not predict the rounded fixed point unless the quantizer is included.
Compute each stored update from the previous stored value, not from an independently maintained unrounded reference. Otherwise a simulation can accidentally implement rounding only for display, while its hidden state continues to evolve in exact or floating-point arithmetic. Rounding a plotted value is not the same operation as rounding the state fed back into the next update. This distinction is often the first thing to check when a demonstration unexpectedly decays despite claiming to implement a fixed-grid feedback recurrence.
| Update index | Stored state | Next intermediate value | Next stored state |
|---|---|---|---|
| 0 | 7 | 5.6 | 6 |
| 1 | 6 | 4.8 | 5 |
| 2 | 5 | 4 | 4 |
| 3 | 4 | 3.2 | 3 |
| 4 | 3 | 2.4 | 2 |
| 5 | 2 | 1.6 | 2 |
CHAPTER 6 OF 34 · Define and trace the stored state
6. Derive the fixed-point condition
An integer m is fixed when Q(am)=m. Away from a tie boundary, nearest rounding requires m−1/2<am<m+1/2. Equivalently, |(1−a)m|<1/2, with boundary inclusion determined by the declared tie rule.
For a=4/5 this becomes |m|<5/2. The integer candidates are −2,−1,0,1,2, and direct substitution confirms all five. No half-integer tie appears because (4/5)m has fractional part in fifths for integer m.
The derivation gives a reason for the small residual states rather than merely listing a simulation. It also shows how coefficient changes can alter the fixed-point set. Do not apply the strict interior inequality as a complete classification when a candidate lies exactly on a tie boundary; the quantizer’s tie convention then becomes part of the answer. We will examine such a boundary separately.
CHAPTER 7 OF 34 · Define and trace the stored state
7. Classify every integer startup state for the original update
For positive integer m≥3, Q((4/5)m) is at least two and at most m−1. The lower bound follows because the intermediate value is at least 2.4; the upper bound follows from the distance between m and 0.8m.
Therefore a positive trajectory starting at three or above decreases through positive integers until it reaches two, where it stays. A startup value of one remains one, and zero remains zero. By symmetry, negative startup values of magnitude at least three approach negative two; negative one stays negative one.
This is a complete classification for the specified one-state nearest-rounding map on integer states. It is stronger than checking the first few initial values numerically, but it is not a theorem for every quantized digital filter. Higher-order recurrences, different quantizers, saturation and time-varying coefficients can produce different attractors and require their own analysis.
Now implement s[n+1]=Q(−(4/5)s[n]). The corresponding exact linear recurrence still decays, because its coefficient magnitude remains 4/5. Its signs alternate as its magnitude shrinks.
The rounded map instead sends one to negative one and negative one back to one. It sends two to negative two and negative two back to two. These are zero-input two-cycles.
The magnitude update is the same as the positive-coefficient example, so startup magnitudes at least three eventually reach magnitude two, while magnitude one stays one. Nonzero signs then alternate. This controlled sign change separates a fixed residual from an oscillating residual without changing the unrounded decay factor. A plot showing alternating signs is not by itself evidence of unbounded instability; here the cycle amplitudes are exactly bounded and can be verified at each step.
For nearest rounding, define e[n]=Q(as[n])−as[n]. Its absolute value is at most 1/2 in grid units. The stored recurrence can therefore be written s[n+1]=as[n]+e[n].
This identity is exact, but e[n] is generally a deterministic function of the state. It is not automatically independent, uniformly distributed or white noise. In a fixed point, the same error repeats because the same intermediate value repeats.
For a=4/5 and s[n]=1, the error is +1/5 every update. That error exactly offsets the unrounded loss of one-fifth. For s[n]=2, the error is +2/5. The error-term representation explains the persistence while keeping the nonlinear dependence visible. Treating those repeated errors as independent zero-mean draws would describe a different model and fail to reproduce the fixed trajectory.
CHAPTER 10 OF 34 · Bound and separate the errors
10. Derive a deterministic magnitude envelope
From |s[n+1]|≤|a||s[n]|+1/2, repeated substitution gives |s[n]|≤|a|^n|s[0]|+(1/2)Σ_j=0^(n−1)|a|^j.
For |a|<1, the finite sum is [1−|a|^n]/[1−|a|]. Thus the bound becomes |a|^n|s[0]|+[1−|a|^n]/[2(1−|a|)].
For |a|=4/5, its long-run envelope approaches 5/2 grid units. Our fixed magnitudes one and two and the two-cycle amplitudes satisfy that bound. The envelope does not claim that every trajectory reaches 2.5, which is not an integer state here. It bounds possible magnitudes under the stated error limit. A bounded envelope and convergence to zero are distinct conclusions, and the recurrence supplies an explicit example where the first holds while the second fails.
CHAPTER 11 OF 34 · Bound and separate the errors
11. Keep the error envelope separate from a noise spectrum
The deterministic bound uses only |e[n]|≤1/2. It allows persistent, correlated and state-dependent error sequences. It therefore applies to our exact rounding examples without assuming an error probability distribution.
A white-noise approximation might be useful in some signal-processing analyses under justified operating conditions, but it does not follow merely from rounding to nearest. A fixed point has a constant error sequence, and a two-cycle has a repeating one. Their spectral behaviour is not that of independent random errors.
When a report switches from a deterministic bound to a stochastic noise calculation, identify the extra assumptions and validate them against the intended inputs and states. A random-noise approximation can answer a useful average-power question while missing a zero-input attractor. Neither result should be substituted for the other without showing that it addresses the same implementation property.
CHAPTER 12 OF 34 · Bound and separate the errors
12. Restore a physical grid spacing
Let the physical state be x_q[n]=Δs[n], with Δ>0. The quantizer Q_Δ rounds to the nearest multiple of Δ, and the recurrence is x_q[n+1]=Q_Δ(ax_q[n]).
The one-step rounding error is bounded by Δ/2. The envelope becomes |x_q[n]|≤|a|^n|x_q[0]|+Δ[1−|a|^n]/[2(1−|a|)]. For a magnitude of 4/5, the long-run envelope is 2.5Δ.
Reducing Δ shrinks the possible physical residual scale under this model, but it does not make every nonzero fixed-grid initial state decay exactly to zero. The fixed states ±Δ and ±2Δ remain possible for each positive Δ. This separates physical error tolerance from mathematical convergence. A design may accept a small bounded residual for its task, but it should not describe that acceptance as proof that the quantized recurrence has the same asymptotic trajectories as the exact linear model.
CHAPTER 13 OF 34 · Bound and separate the errors
13. Compare rounding at each step with rounding only the display
Suppose a program stores the exact state x[n]=(4/5)^n and rounds it only when printing. Its displayed values may remain one for several samples, but eventually the exact internal value falls below one-half and the display becomes zero.
In contrast, the feedback-quantized implementation stores one again after every update, so its intermediate input remains 0.8 forever. The later trajectory is altered by the earlier rounding decision.
A practical implementation audit should identify the storage format and every place where rounding occurs: coefficient conversion, multiplication result, accumulator, state assignment and output display. Their order can matter. A program that uses a high-precision internal state and an integer-looking plot has not demonstrated fixed-grid state feedback. Our one-state example is deliberately small enough that the actual stored value can be logged and checked at every update rather than inferred from the rendered graph.
CHAPTER 14 OF 34 · Bound and separate the errors
14. Distinguish coefficient approximation from state quantization
The original coefficient 4/5 was treated as an exact rational number. A particular binary fixed-point format may approximate it by another representable value, introducing a second mechanism.
Changing a coefficient can move the pole of the unrounded linear model and alter the quantized fixed-point conditions. State rounding can create nondecay even when that coefficient is represented exactly and its magnitude remains below one.
Test these mechanisms separately before combining them. First verify an exact rational recurrence with the declared quantizer; then substitute the implemented coefficient and repeat the state analysis. If the rounded coefficient reaches or exceeds unit magnitude, the linear stability question itself has changed. If it remains inside the unit circle, quantized attractors can still matter. A single phrase such as finite precision does not identify which part of the implementation produced an observed discrepancy.
CHAPTER 15 OF 34 · Change the quantizer and coefficient
15. Treat overflow and saturation as additional models
A bounded register can wrap around after an overflow or clip at a saturation limit. Neither operation was included in our original recurrence, whose integer state was allowed arbitrary finite range.
Saturation changes the update at large magnitudes, and wraparound can change signs and values discontinuously. Their trajectories and safety implications need a declared word length, signed representation, scale and arithmetic rule.
Do not claim that the nearest-rounding envelope certifies an implementation whose intermediate multiplication overflows before rounding. The bound assumed the arithmetic value as[n] was correctly formed. Likewise, observing no overflow in a short test does not prove it cannot occur for all allowed inputs and initial states. State the implementation property being checked and its admissible range. The small examples here establish quantization-induced nondecay under clean assumptions, rather than silently certifying every other finite-word-length behaviour.
CHAPTER 16 OF 34 · Change the quantizer and coefficient
16. Compare truncation toward zero
Define T(v) as truncation toward zero to the nearest integer of no greater magnitude. For positive v it is floor(v); for negative v it is minus floor(|v|).
Under s[n+1]=T((4/5)s[n]), a nonzero integer state has strictly smaller magnitude after each update. For integer m≥1, floor((4/5)m)≤m−1. Therefore every finite integer initial state reaches zero in finitely many steps.
The same magnitude argument applies to a coefficient −4/5: signs can alternate, but the integer magnitude decreases until zero. This is a property of this specified scalar map with no other arithmetic effects. It does not establish that truncation universally solves every higher-order filter’s limit-cycle or accuracy problem. A changed quantizer also changes response errors under nonzero input, so the zero-input convergence benefit must be assessed alongside the task’s other requirements.
CHAPTER 17 OF 34 · Change the quantizer and coefficient
17. Work the truncation trajectory independently
Starting from seven with coefficient 4/5, truncation gives 7→5→4→3→2→1→0. The nearest-rounding trajectory instead ended at two.
Starting from negative seven, truncation toward zero gives −7→−5→−4→−3→−2→−1→0. Using a mathematical floor for every signed value would produce a different rule: floor(−0.8)=−1, so negative one could persist.
This sign test is essential when translating a quantizer definition into code. The words truncate and floor are not interchangeable for negative inputs. Choose examples on both sides of zero and compare exact updates with the intended arithmetic convention. A passing positive-only test can conceal an asymmetric negative-state failure. Keep the rule in the implementation record rather than assuming a language’s conversion or library function has the desired behaviour.
CHAPTER 18 OF 34 · Change the quantizer and coefficient
18. Examine the half-integer tie boundary
Use coefficient a=1/2 and integer startup state one. The intermediate value is exactly 1/2. Under our original nearest rule with ties away from zero, it rounds to one, creating a fixed point.
Under nearest rounding with ties to even, the same intermediate value rounds to zero. Starting from negative one similarly distinguishes the two conventions. The unrounded recurrence is unchanged, but the implemented map differs at its boundary values.
This is why a proof using |e[n]|≤1/2 alone cannot classify every attractor: it supplies a bound but does not specify which boundary error is chosen. For the coefficient 4/5, no integer intermediate is a half-integer, so the original classifications did not depend on this tie choice. A changed coefficient can make a previously irrelevant implementation detail decisive. Include a tie test when claiming behaviour for a particular rounding convention.
CHAPTER 19 OF 34 · Change the quantizer and coefficient
19. Derive a sufficient condition for no nonzero fixed integer state
For a positive coefficient 0≤a<1 under nearest rounding, any nonzero fixed integer m must satisfy approximately |m|≤1/[2(1−a)], with equality checked against the tie rule.
If 0≤a<1/2, this bound is strictly smaller than one. No nonzero integer fixed state is possible. More directly, for every positive integer m, am<m−1/2 when a<1/2, so nearest rounding reduces its magnitude.
Thus every finite integer initial state reaches zero for this scalar map when |a|<1/2, using symmetry for negative coefficients. The strict inequality avoids the tie-sensitive a=1/2 boundary. This gives an independent changed-coefficient check on the original example: quantization does not force nondecay for every stable coefficient. The exact linear stability condition |a|<1 is broader than this simple nearest-rounding convergence condition, and confusing them would miss the interval where small attractors can persist.
CHAPTER 20 OF 34 · Change the quantizer and coefficient
20. Try a changed coefficient and grid
Let a=3/5 and physical grid spacing Δ=0.1. Predict the nearest-rounded fixed states and the long-run envelope before tracing a trajectory.
The fixed-state condition in grid units is |m|<1/[2(1−3/5)]=5/4, so m=−1,0,1 are the fixed integers. In physical units they are −0.1, zero and 0.1. The deterministic long-run magnitude envelope is 0.125.
From s[0]=4, nearest rounding gives 4→2→1→1, corresponding to 0.4→0.2→0.1→0.1. With coefficient −3/5, the magnitude reaches one and then the physical state alternates between ±0.1. Recalculate the updates with the declared tie rule; no half-integer tie occurs for these integer states. The changed coefficient and scale test the fixed-point argument and units, not just memory of the original residual values one and two.
CHAPTER 21 OF 34 · Change the quantizer and coefficient
21. Check a coefficient that does converge under nearest rounding
Use a=1/3 with grid spacing one. From seven, nearest rounding gives 7→2→1→0. From negative seven it gives the sign-reversed sequence and also reaches zero.
For any nonzero integer magnitude m, the intermediate magnitude m/3 lies more than one-half below m. Nearest rounding therefore gives a strictly smaller integer magnitude. This proves finite-time arrival at zero for every finite integer startup state under the declared scalar map.
The contrast with a=4/5 is useful because both unrounded models are stable. Their nearest-rounded implementations have different convergence properties. A statement that “rounding can create residual states” is true as a possibility, but it should not be inflated into “every rounded stable recurrence has a limit cycle.” The changed case supplies a concrete boundary on that claim and a simple test for an implementation intended to follow the specified arithmetic.
CHAPTER 22 OF 34 · Verify the implemented property
22. Explain eventual periodicity with a finite state set
A deterministic map on a finite set of states must eventually repeat a state. Once it repeats, its future trajectory repeats as well, producing a fixed point or a cycle.
For the one-state rounded recurrence with |a|<1, the magnitude envelope provides a finite bound for a specified finite startup state. Intersecting that bound with the integer grid leaves finitely many possible stored values, so eventual periodicity follows under exact evaluation of the declared map.
This argument establishes eventual repetition, not the period or amplitude. The explicit one-state analysis classified those for a=±4/5. Higher-dimensional quantized systems can have many more possible states and cycles, and an implementation can have additional arithmetic rules. A finite-state argument is a useful conceptual tool, but it should not be presented as a practical exhaustive verification unless the relevant state space and all admissible transitions were actually checked.
CHAPTER 23 OF 34 · Verify the implemented property
23. Keep zero-input behaviour separate from driven response
Our fixed points and cycles were demonstrated with zero external input. A nonzero input changes the intermediate value and can move the state between grid cells, alter an attractor or introduce other patterns.
For an update s[n+1]=Q(as[n]+u[n]), nearest-rounding error remains bounded by one-half if the intermediate arithmetic is exact. A bounded-input envelope can be derived by including the input bound, but that does not classify every driven trajectory.
A zero-input convergence test and a signal-fidelity test answer different questions. An implementation may have acceptable behaviour for a particular driven signal while retaining a small zero-input residual after the signal stops. Conversely, a quantizer that forces zero-input decay can introduce a systematic bias under small driven inputs. State the operating condition and performance criterion rather than using one successful experiment to certify every aspect of a filter.
CHAPTER 24 OF 34 · Verify the implemented property
24. Distinguish a bounded residual from unbounded divergence
In the original nearest-rounded map, the error bound and |a|<1 prevent unbounded state growth under zero input. Nevertheless some initial conditions do not converge to zero. Those two facts are compatible.
A report should describe the failed property precisely: asymptotic decay to zero, absence of periodic output, an acceptable residual magnitude or a required response tolerance. The word stability can carry different definitions across linear, nonlinear and implementation contexts.
If a physical application requires a residual below a threshold ε, compare that threshold with the grid-scaled bound and the actual attractor classification. Passing that engineering tolerance does not change the mathematical fact that a nonzero fixed state exists. Failing zero convergence does not by itself establish a dangerous physical outcome. The model, units, range and task must connect the mathematical behaviour to a meaningful decision.
CHAPTER 25 OF 34 · Verify the implemented property
25. Test the actual stored update
Log the old state, exact or high-precision intermediate value, quantizer decision and new stored state. For a multi-variable update, compute all next values from the old state before assigning them, unless the intended algorithm explicitly uses sequential updates.
Begin with zero, ±1, ±2 and several larger startup magnitudes. Include negative coefficients and a half-integer tie example. Compare each recorded update with the declared map, then test the predicted fixed points and two-cycles over more than one period.
Do not infer a cycle solely from a rounded display. Two different internal values can print identically, while a true fixed-grid state is exactly repeated. Conversely, a hidden high-precision accumulator can make a display appear to pause and later decay. The evidence should identify the stored arithmetic state and the update rule that actually feeds it back.
CHAPTER 26 OF 34 · Verify the implemented property
26. Use independent proofs and exhaustive small tests together
For a finite range such as integer startup states −30 through thirty, enumerate trajectories and compare them with the derived envelope and attractor predictions. Such tests can catch indexing, sign and quantizer errors.
The monotone-magnitude argument proves the original scalar classification beyond that finite test range. The tests do not replace the proof, and the proof does not establish that code implements its premises. Combining them gives a stronger account: the mathematics states the expected behaviour, and the implementation checks whether the specified transitions were executed.
If a tool uses bounded model checking or another formal method, record its model, property, initial-state constraints and horizon. A bounded successful search is not automatically a proof about every future step unless an induction or complete-state argument supplies that extension. The small recurrence here makes those evidence boundaries visible without requiring a particular verification package.
CHAPTER 27 OF 34 · Verify the implemented property
27. Connect the implementation issue to primary sources
MIT's IIR-filter design notes identify quantization-induced limit cycles as a nonlinear implementation issue. The original scalar coefficients, state classifications and bounds in this article are independently worked examples.
The author paper Verifying Fixed-Point Digital Filters using SMT-Based Bounded Model Checking describes verification of finite-word-length effects including limit cycles, overflow and timing. Its existence does not certify a reader’s code or make every finite test exhaustive.
Use such sources to understand the implementation questions and verification scope. Then write the actual arithmetic contract for the system under study. A theorem about a linear transfer function, a result from a specific implementation model and a finite simulation trace are different kinds of evidence. Keeping their assumptions beside their conclusions makes each more useful.
CHAPTER 28 OF 34 · Verify the implemented property
28. Compare this issue with hidden-mode cancellation
The Z-Transform guide to cancelled poles and hidden internal modes demonstrates a stable selected output alongside an unstable internal mode in an exact linear realization.
Our rounding example has a different mechanism. The original one-state linear model decays, but the implemented update is nonlinear because of quantization. Its nonzero residual is bounded in the specified example. There is no hidden second linear state required to produce it.
Both guides teach the importance of naming the implemented state equations rather than relying on a simplified external description. They should not be merged into a claim that every implementation discrepancy is a cancelled pole. A sound diagnosis asks which operation changed: the measurement map, realization, coefficient, quantizer, timing or arithmetic range. The original recurrence and a one-step trace help locate that change.
A pole inside the unit circle certifies every rounded implementation: it certifies the corresponding exact causal linear model under its assumptions, not every nonlinear state update. Rounding errors are automatically independent white noise: our fixed and alternating error sequences disprove that assumption in these examples.
A nondecaying residual must grow without bound: the derived envelope and exact fixed points show otherwise. Truncation is the same as floor for all signed values: the negative-state test disproves that claim.
The best repair is concrete. Write one intermediate value, apply the exact quantizer, and feed the stored result into the next step. Then state the property being tested and the assumptions needed for its proof. This sequence makes the implementation difference visible before introducing broader terminology such as limit cycle, numerical stability or finite-word-length verification.
Does floating-point arithmetic automatically remove this concern?
No universal guarantee follows from changing the format name. The actual rounding, range and update still matter. This article’s proofs concern its explicitly declared uniform fixed grid, not every floating-point implementation.
Is a nonzero fixed point a cycle?
It can be regarded as a period-one orbit. We distinguish it from the alternating period-two examples because their observable behaviour differs.
Can the grid be chosen small enough for a tolerance?
The envelope scales with Δ, so it can support a conditional tolerance calculation. Additional input, coefficient and arithmetic errors must be included if the implementation has them.
Does truncation always solve every filter problem?
No. We proved finite-time decay for a particular scalar zero-input map. Other filters and driven-response criteria require separate analysis.
Why declare a tie rule when the original example has no ties?
It completes the implementation definition and makes changed-coefficient tests reproducible. The a=1/2 example shows when that previously irrelevant detail becomes decisive.
CHAPTER 31 OF 34 · Reproduce and assess tolerance
31. Reproduce the original and changed examples
Trace the nearest-rounded a=4/5 map from zero, one, two, seven and their negatives. Confirm its fixed states and the trajectory ending at two. Reverse the coefficient sign and confirm the two-cycles.
Then implement truncation toward zero and check finite-time decay, including negative startup states. Test a=1/2 under two tie conventions, followed by a=3/5 on a physical grid of 0.1 and a=1/3 on the unit grid.
For every experiment, compare the actual stored states with the magnitude envelope. Explain why a bound can hold even when zero convergence fails. This is a more informative transfer test than running a long simulation from zero alone, because the changed states and arithmetic rules expose the precise assumptions supporting each conclusion.
CHAPTER 32 OF 34 · Reproduce and assess tolerance
32. Translate a residual tolerance into a grid requirement
For the original coefficient magnitude 4/5, the deterministic long-run envelope is 2.5Δ. If a fictional task permits a residual magnitude of at most 0.01 in the physical state units, the envelope can certify that asymptotic bound when Δ≤0.004, under the stated model.
This calculation does not specify a complete word length because the required dynamic range is another input. A grid fine enough near zero can still be inadequate at large state magnitudes if the storage range is too small. It also does not promise an immediate bound of 0.01 after startup: the transient term |a|^n|x_q[0]| remains in the finite-time envelope.
For a specified finite settling index, use the whole inequality and the declared startup bound. Separate the remaining transient from the quantization contribution instead of labelling the long-run envelope a universal per-sample limit. The conditional calculation is useful precisely because its missing implementation and operating assumptions remain visible.
CHAPTER 33 OF 34 · Reproduce and assess tolerance
33. Compare quantization error with the exact reference trajectory
Let the rounded and exact recurrences start from the same grid value. Subtract their updates. The trajectory difference d[n] obeys d[n+1]=ad[n]+e[n], with d[0]=0 and |e[n]|≤Δ/2.
Therefore |d[n]|≤Δ[1−|a|^n]/[2(1−|a|)]. This bounds the accumulated difference from the ideal trajectory separately from the magnitude of the rounded state itself. For a=4/5 it approaches 2.5Δ.
The original fixed state x_q[n]=Δ and exact trajectory Δ(4/5)^n give difference Δ[1−(4/5)^n], which satisfies the bound. The inequality permits a family of bounded error sequences; the actual state-dependent sequence is only one member of that family.
This distinction supports a useful implementation check: compare the stored trajectory with an independently computed exact reference under matching initial conditions, then assess the observed difference against the derived envelope. Passing this comparison verifies that particular error criterion under its assumptions; it does not convert a bounded discrepancy into exact agreement or zero-input convergence.
CHAPTER 34 OF 34 · Reproduce and assess tolerance
34. Continue through the relevant learning routes
Return to the Z-Transform subject guide for exact linear sequences, poles, regions of convergence and realizations. The hidden internal-mode guide supplies a complementary state-based counterexample under exact linear arithmetic.
Use The Gold Standard of Education: Learning Transfers into Life to connect the original and changed-context checks to a wider learning practice. The How X Works hub provides further subjects where an ideal equation and its implemented rule must be distinguished.
A useful last check is to ask which result would change if the grid spacing halved, the coefficient changed sign or the rounding rule became truncation. Predict each change before running the code, then compare the actual stored sequence with that prediction.
A clear final explanation states the quantizer, grid, coefficient, startup set and property checked. It then gives the actual trajectories, the proven bounds and the additional implementation details needed before applying the conclusion to a real device.
For the indexing of a transform-based implementation, the short-DFT convolution guide derives exact tail folding and support requirements. Its direct signed examples complement the stored-state arithmetic checks here.