Methods of Error Detection

Parity bit is an extra bit appended to a byte to make the total number of 1s either EVEN (even parity) or ODD (odd parity).

How it's used:

1. Sender counts 1s in the data, then adds a parity bit to enforce the chosen convention.
2. Receiver counts 1s in the entire received byte (data + parity).
3. If the count violates the convention, an error is detected.

Worked example. Data 1011010 with EVEN parity:

• Count 1s in data: 4 (already even).
• Parity bit: 0 (keep total at 4).
• Transmitted byte: 10110100 (or 01011010 if parity at start).

Worked example. Receiver gets 10101011, even parity expected:

• Count 1s: 5.
• 5 is odd → error detected.

Limitations.

• Parity detects an ODD number of bit flips (1, 3, 5...).
• It DOES NOT detect an EVEN number of bit flips (2, 4...) — they cancel out and leave parity intact.
• Cannot identify WHICH bit was flipped or correct the error. Just signals "something's wrong".

Cambridge tip. Mark schemes for parity questions ALWAYS expect (a) the convention (even/odd) stated, (b) the count, (c) the conclusion. Top-band candidates also note the multi-bit limitation.

Checksum: a value calculated from the data (typically by summing the bytes) and transmitted alongside it. The receiver re-calculates the checksum and compares.

How it works:

1. Sender computes checksum (e.g., sum of all bytes mod 256).
2. Sender transmits data + checksum.
3. Receiver re-computes checksum on received data.
4. Receiver compares to received checksum.
5. If different → error detected.

Worked example. Data: 110, 45, 200. Checksum (sum mod 256) = 355 mod 256 = 99.

If transmission is clean, receiver sums the same bytes, gets 355 mod 256 = 99, matches the transmitted checksum. ✓

If a byte is corrupted (110 → 113), receiver computes 113+45+200 = 358 mod 256 = 102. 102 ≠ 99 → error detected.

Stronger than parity because it's sensitive to each byte's value, not just bit counts.

Used in: IP packets (header checksum), TCP, file transfers, archive formats.

Limitation. Coincidental cancellation can still occur — extremely rare in practice for any non-trivial checksum.

Check digits are extra digits appended to long numbers (barcodes, ISBNs, credit-card numbers). They're calculated by an algorithm from the other digits.

How it works:

1. Algorithm runs on the original digits → produces a single digit.
2. That digit is appended to the number.
3. When the number is later read or entered, the algorithm runs again.
4. If the recomputed check digit doesn't match the appended one, an error is flagged.

Examples:

• ISBN-10: weighted-sum-mod-11 algorithm. Catches single-digit errors and most digit-swap errors.
• Credit cards: Luhn algorithm.
• EAN-13 barcodes: weighted-sum-mod-10.

Why it matters. Humans regularly enter long numbers and make typos. Check digits make these typos detectable BEFORE the wrong number is acted on (e.g., before charging the wrong credit card).

Cambridge tip. Mark schemes don't usually require the algorithm itself — just the concept (extra digit, computed from data, used for validation) and an example.

Echo check: the receiver sends the data BACK to the sender, who compares it to the original.

Process:

1. Sender transmits data.
2. Receiver immediately retransmits the same data back to the sender.
3. Sender compares.
4. If different → error somewhere in transmission. Sender retransmits.

Pros: Simple to implement.

Cons: Doubles the bandwidth used (every transmission travels each way). And: if the transmission is corrupted in BOTH directions in compatible ways, the error may go undetected.

Used: rarely in modern systems, replaced by checksums + ARQ. But appears in 0478 syllabus as a textbook concept.

Cambridge tip. Echo check is the easiest method to describe but the worst at scale. Memorise the bandwidth-cost criticism for evaluation marks.

ARQ is a protocol that combines error detection with automatic retransmission.

Process:

1. Sender transmits data + error-detection code (parity / checksum / CRC).
2. Receiver checks for errors using the code.
3. If OK: receiver sends a positive acknowledgement (ACK) back to sender.
4. If errors found: receiver sends a negative acknowledgement (NACK) OR no acknowledgement at all.
5. Sender starts a TIMER when it transmits. If no ACK arrives before the timeout expires, sender assumes the packet was lost or corrupted.
6. Sender automatically retransmits.
7. Process repeats up to a maximum retry count.

Why timeouts matter. ACKs themselves can be lost. Without a timeout, sender would wait forever for an ACK that won't come.

Where ARQ is used:

• TCP (the protocol underlying most internet traffic).
• Reliable wireless protocols (Wi-Fi at the data-link layer).
• File-transfer protocols.
• Most modern reliable-delivery systems.

Variants.

• Stop-and-wait ARQ: send one packet, wait for ACK, then send next. Simple but slow.
• Go-back-N ARQ: send N packets at once; if any fails, retransmit from that one onwards.
• Selective repeat ARQ: only retransmit the specific packet that failed. Most efficient.

Cambridge tip. Mark scheme for ARQ questions explicitly expects mention of (a) ACK / NACK, (b) TIMEOUT, (c) retransmission. Top-band answers also reference TCP as a real-world example.