Vertical Redundancy Check: A Beginner’s Guide to Parity
How does a computer know a byte got scrambled somewhere along a noisy cable? One of the oldest answers is a single extra bit. A vertical redundancy check, or VRC, tacks that bit onto every character so the receiver can spot damage. It’s cheap and simple. It’s also full of holes.
This guide covers what VRC is, how to calculate it by hand, where it breaks, and why modern networks moved on to CRC. If you’re prepping for a networking exam, you’ll finish with a worked example you can repeat on paper.
What Is a Vertical Redundancy Check?
A vertical redundancy check is an error detection method that appends one parity bit to each data unit, usually a 7-bit or 8-bit character. Plenty of textbooks simply call it a parity check. In an 8-bit ASCII byte, the spare eighth bit is the one that carries it. The extra bit forces the count of 1s in the unit to be even or odd, following a rule the sender and receiver agreed on beforehand.
The parity bit is redundant because it adds no new information about the message. It only describes the message. The receiver recounts the 1s, and if the total breaks the agreed rule, something changed in transit.
Where does “vertical” come from? In most diagrams, characters are stacked as rows, and each row gets a check bit in a column beside it. Its sibling, the longitudinal redundancy check (LRC), builds a check row across the columns instead. Both belong to the data link layer in the classic teaching model.
Even Parity vs. Odd Parity
With even parity, the sender chooses the bit so the total number of 1s, parity bit included, comes out even. Odd parity reverses the rule. Under the hood, parity is an XOR sum of the bits, yielding 0 for even parity and 1 for odd parity.
Which one should you pick? Honestly, it barely matters as long as both ends agree. Even parity shows up more in textbooks. Some engineers prefer odd parity because an all-zero unit produces a 1 in the check position, so a line stuck at zero gets flagged.
How VRC Works, Step by Step
Let’s encode the letter C.
- Convert to binary. ASCII “C” is decimal 67, which is 1000011 in seven bits.
- Count the 1s. There are three.
- Pick even parity. Three is odd, so the parity bit is 1.
- Append it. The transmitted unit is 10000111, which holds four 1s.
- Check at the receiver. Four is even, so the unit passes.
Now break something. Suppose noise flips the third bit and the receiver gets 10100111. That’s five 1s, an odd count, so the receiver rejects the unit and asks for a resend. Error caught.
Now flip two bits instead, the second and third, giving 11100111. Count again: six 1s, even. The receiver shrugs and accepts corrupted data. Not great, right?
What a Vertical Redundancy Check Can and Can’t Catch
The rule is short. VRC detects any odd number of flipped bits and misses any even number. As one university course handout explains, a single parity bit can’t reveal which bit is wrong, so the error can’t be corrected and the data must be retransmitted.
That has real consequences. Line noise rarely flips just one bit. It often hits a run of neighboring bits, called a burst error. A burst that flips an even number of bits sails through, so for random multi-bit damage you’re close to flipping a coin.
Then there’s cost. Seven data bits plus one check bit means about 14% overhead for protection this thin. Compare that with CRC-32 on an Ethernet frame: four bytes guarding up to 1,500 bytes of payload, roughly 0.27% overhead, with far stronger detection.
Can parity ever locate an error? Not alone. Pair VRC with LRC and you get two-dimensional parity, where a failed row and a failed column pinpoint one flipped bit. A University of Central Oklahoma networking page walks through this with a small table of bits, which makes a handy exercise.
VRC vs LRC vs CRC
| Method | What it checks | Catches | Misses |
|---|---|---|---|
| VRC | One parity bit per character | Any odd number of flips in that character | Even numbers of flips in one character |
| LRC | One parity byte per block, column-wise | Many bursts up to the check length | Matching flips in the same columns across rows |
| CRC | Polynomial remainder over the whole frame | All bursts up to the check length, most longer ones | Rare, deliberately crafted collisions |
CRC wins because it treats the frame as one big binary number and divides it by an agreed polynomial. The remainder rides along as the check value. It needs more hardware than a parity generator, though today’s network chips handle it without breaking a sweat.
Where Parity Still Shows Up
VRC isn’t dead; it just moved. Parity survives wherever a failed check can simply be retried. SCSI and PCI buses use it, and many processor instruction caches do too, since a corrupted cached copy can be discarded and re-fetched from main memory. Classic serial links often run 7 data bits plus an even parity bit.
Common Mistakes Students Make
- Leaving the parity bit out of the count at the receiver. It’s part of the total.
- Mixing up the even and odd rules halfway through a problem.
- Assuming detection means correction. Parity says “something broke,” never “here.”
- Treating a pass as proof. A passing check only means the count looks right, which is different from “the data is fine.”
A habit that saves marks: write the unit down, circle every 1, count twice. Boring, but it works.
Try It Yourself
Problem 1. Encode “H” (ASCII 72, or 1001000) with odd parity.
Problem 2. A receiver using even parity gets 01001100. Accept or reject?
Answers: For the first, 1001000 has two 1s, so odd parity needs a parity bit of 1, giving 10010001. For the second, the unit holds three 1s, an odd count, so it fails even parity and gets rejected.
