Noisy Transmission

Channel capacity is a reliable-rate ceiling. Any code carrying fewer than 0.53 data bits per channel use can be made as close to error-free as you like by using long enough blocks; no code above that rate can, however much redundancy it adds.

A binary symmetric channel flips each transmitted bit independently with probability p, and the receiver cannot see which bits changed. With p = 0.001 a thousand-bit block averages one flip, yet only about 37 percent of blocks arrive clean.

Repair has two halves: finding the damaged position and fixing its value. An erasure hands you the position for free, so only the value must be recovered, which takes roughly half the redundancy a silent flip of unknown location needs.

An additive sum is unchanged by reordering whole words, by inserting or deleting a word that adds nothing, and by two changes that cancel each other. Any change confined to a single word is caught, which is what makes the holes structural rather than random.

A CRC reads the frame's bits as the coefficients of a polynomial, shifts it left by the generator's degree r, and divides by a fixed generator polynomial in GF(2) arithmetic, where addition is XOR and nothing carries. The r-bit remainder is the check field.

Minimum distance 3 corrects one flipped bit or detects two, but not both at once. Correcting t flips needs distance at least 2t+1; detecting e flips needs only e+1. Correction costs about twice the distance detection does.

Each check covers a fixed subset of positions, chosen so the three recomputed checks read as a binary number equal the index of the flipped bit. That number is the syndrome; zero means no single flip was seen.

An unknown-position error hides two things, where it is and what it should be, so it consumes two parity symbols. A known-position loss hides only the value, so it consumes one. With n minus k parity symbols the code repairs that many erasures but only half as many errors.

A CRC is keyless and public, so anyone who edits the payload simply recomputes the field. Worse, it is linear: an attacker who knows only which bit positions they flipped can patch the check field without seeing the payload at all. It detects noise, not intent.

Overhead falls from three times the blob to about 1.4 times, and tolerated simultaneous losses rise from two copies to any four fragments. The price is paid on the read and repair paths, and only if placement keeps the fourteen fragments genuinely independent.

Multiply capacity by the number of channel uses per second to get the reliable bits-per-second ceiling, then pick a code rate k/n strictly under 0.53. Payload throughput is that rate times the symbol rate, with margin left for a worse-than-modelled channel.

A Fletcher-style checksum accumulates a second sum over the running first sum, which weights each word by its distance from the end. That makes the check order-sensitive and closes a plain additive sum's blindness to reordered words, at two additions per word.

A corrupt frame escapes only when the generator divides the error pattern exactly. That yields hard guarantees: every single flipped bit, every burst of length at most r, and every odd number of flipped bits when the generator has (x + 1) as a factor.

Reed-Solomon treats each m-bit group as one symbol in a finite field, so contiguous damage that mangles many adjacent bits still costs one symbol. Exact field arithmetic is what lets any k of n symbols rebuild the rest.

Capacity grows with the logarithm of the signal-to-noise power ratio, so each doubling of power adds only about one more bit per second per hertz. Bandwidth sits outside the logarithm as a multiplier, which is why a starved link is starved.

Noise fixes only how outputs follow from inputs. How much information actually gets through also depends on how the sender drives the input, so capacity is the best achievable over all input distributions - the maximum mutual information per channel use.

The average rate is right but the memoryless assumption is wrong. Fading concentrates errors into bursts, so most blocks arrive perfectly clean while the few blocks a burst touches carry far more errors than any fixed repair budget covers.

Model the two layers separately: bit flips within frames that arrive, and whole-frame loss as a burst erasure of every symbol in that frame at once. A dropped frame is only an erasure if something marks the gap; otherwise the stream silently shortens.

A failed check proves only that the covered bytes differ from what the sender summed. It names no position, quantifies no damage, repairs nothing, and leaves exactly one recovery path: discard the whole covered unit and obtain it again.

The extra bit covers every position, so it fails on an odd number of flips and passes on an even one. That raises the minimum distance from 3 to 4 and lets the decoder separate one flip from two instead of miscorrecting the pair.

Nothing on disk equals the missing fragment, so it must be recomputed: the repair reads ten surviving fragments, a whole blob's worth of traffic, to restore a tenth of a blob. Replication restores a lost copy by copying one copy.

Work backwards from a failure budget: frame rate times corrupted fraction times the residual must sit under the tolerable rate of undetected frames. That sets the width; the link's noise structure and the maximum frame length then pick a published, characterised generator.

Repair is only applied when a word is read, so rarely touched words accumulate flips until two share one word and correction fails. A background scrub that reads and rewrites every word on a fixed period bounds that accumulation window, and the corrected-error counts it produces drive retirement decisions.

Set n minus k from the correlated failures placement can actually isolate, then pick k as wide as the repair and read fan-out can absorb, since overhead falls as k rises but repair reads k fragments. Rebuild speed matters as much as the parity count.

Check bits name a position rather than guard a bit, and r checks can name 2^r minus 1 positions. Positions grow exponentially with checks, so the check count grows only logarithmically with word width and the percentage overhead falls.

Interleaving spreads one codeword's symbols far apart, so a contiguous run of damage is shared out across many codewords instead of destroying one. Each codeword then takes a few damaged symbols that fit inside its own repair budget.

The 2^-k figure assumes corruption drives the recomputed check to a value independent of and uniform over the correct one. Structured errors — reordered words, cancelling pairs, faults outside the covered span — break that assumption and pass every time, not one time in 65,536.

It buys exactly two things: guaranteed detection of bursts up to 32 bits instead of 16, and a residual escape rate for unstructured corruption falling from about 1 in 65,536 to about 1 in 4.3 billion. It fixes nothing outside the covered bytes.

The reliability guarantee is asymptotic in block length, so rates near capacity need long blocks a decoder must receive in full before it emits anything. Buying latency back means operating further below capacity and paying in throughput instead.