Tensions in Practice: Adjacent-state readout in tension with redundant error detection¶
Encoded positions · boundary ambiguity and bit corruption
Four physical positions need four labels. A two-bit Gray order changes only one track at each adjacent boundary, so ambiguity in that one changing track gives the old or new label. A three-bit even-parity code instead leaves invalid words that reveal any single-bit corruption. It spends an extra track and changes multiple tracks at a boundary. These are different error contracts, not stronger and weaker versions of one guarantee.
Limit ambiguity at adjacent transitions
Avoid mixing several changing tracks during one designed neighboring-state transition.
Detect any single corrupted bit
Reserve invalid words so flipping one bit cannot silently produce another valid codeword.
Why these aims pull against each other
Nearby valid labels help a transition stay local, but separate valid words are needed to detect corruption. Redundancy changes the set of possible valid words and the track budget.
Choose an arrangement to see what changes and what remains difficult.
Finite illustrative comparisons. Text states carry the meaning; color is not a measured score or universal preference.
What this choice protects
What it costs
When it fits
Compare the arrangements
Gray order
Assign the cyclic sequence 00, 01, 11, 10 to positions 0 through 3.
| Code / result | |
|---|---|
| Position 0 | 00 |
| Position 1 | 01 |
| Position 2 | 11 |
| Position 3 | 10 |
| Tracks | 2 |
| 1 → 2 | 01 → 11 |
| Flip first bit | 00 → 10: valid |
- What it protects
- Every adjacent transition, including 3 to 0, changes one bit; the illustrated 1-to-2 boundary has only one changing track.
- What it costs
- Every two-bit word is valid, so a single bit flip can turn position 0’s 00 into position 3’s 10 without an invalid-word alarm.
- When it fits
- The important uncertainty is confined to one designed neighboring boundary and independent track corruption is handled separately.
Illustration note: This guarantee assumes only the one differing track is ambiguous. Crossing several boundaries or flipping another track is outside it.
Even parity
Use two ordinary binary position bits plus a parity bit, making the total count of 1 bits even.
| Code / result | |
|---|---|
| Position 0 | 000 |
| Position 1 | 011 |
| Position 2 | 101 |
| Position 3 | 110 |
| Tracks | 3 |
| 1 → 2 | 011 → 101 |
| Flip first bit | 000 → 100: invalid |
- What it protects
- Any one bit flip changes even parity to odd parity and is detectable; 100 is therefore invalid.
- What it costs
- One extra track is required. The 011-to-101 boundary changes two tracks, so partial transition reads can be invalid and need handling.
- When it fits
- The read is intended to be a settled codeword and detecting single-bit corruption matters more than one-bit transition adjacency.
Illustration note: The four listed words all have even parity. Detection does not identify which bit failed or correct it, and two-bit changes can produce another valid word.
What this illustration does—and does not—establish
Gray Code supplies local adjacency and its limits. Redundancy-Based Error Detection supplies parity’s detect-only role; the four-word constructions are explicitly enumerated.
- The physical positions and four-message capacity are fixed, but the parity arrangement deliberately spends a third track.
- Neither code proves semantic correctness or protects every corruption pattern.
- An invalid transitional read is not automatically a hardware fault; transition and settled-word contracts must be distinguished.
Source entries
Gray Code
Gray Code: Local transition safety versus global error protection supplies the conflict examined here.
Local transition safety versus global error protection
One-bit adjacency prevents an ambiguous *single designed boundary* from mixing several changing signals, but it adds no redundancy and cannot reconstruct a word arbitrarily corrupted by noise.
Redundancy-Based Error Detection
Supports spending an extra parity symbol for detection without claiming correction.
How it works
- Spend redundancy on detection or correction. A minimal code (single parity bit) only flags that *something* is wrong; a richer code with greater minimum distance can also pinpoint *which* symbols are wrong and flip them back.