Error Detection is the process of identifying whether the data received by a receiver has been corrupted during transmission. In a computer network, data may be changed or corrupted while traveling through a communication medium. Therefore, reliable communication requires mechanisms to detect and, when necessary, correct these errors.
Transmission Error: When data is transmitted from one network node to another, the data may be corrupted because of noise, interference, signal problems, or other transmission issues. The errors caused during data transmission are called Transmission Errors.
Error Control in OSI Model: Error control is mainly associated with the Data Link Layer and Transport Layer of the OSI model. These layers provide mechanisms for detecting and/or handling errors to support reliable data communication.
Types of Transmission Errors
There are mainly two types of transmission errors:

• Bit Error
• Burst Error

1. Bit Error: A bit error occurs when only one bit of a data unit is changed during transmission. It is also called a Single-Bit Error.
Example:
Sender sends: 00000010
Receiver receives: 00001010
Here, only one bit has changed from 0 to 1. Therefore, this is a Bit Error.
2. Burst Error: A burst error occurs when two or more bits within a data unit are affected or corrupted during transmission.
The important point is that the burst length is measured from the first corrupted bit to the last corrupted bit, including all bits between them, whether every bit in between is actually corrupted or not.
For example, if the first corrupted bit occurs at position 3 and the last corrupted bit occurs at position 10, the burst length is 8 bits.
Error Detection: Error detection is the process by which the receiver determines whether the received data contains an error. The receiver normally does not have a copy of the original message, so additional information must be transmitted along with the original data.
To make error detection possible, the sender adds some extra bits to the original data. These extra bits are called Redundant Bits or Redundancy.
Basic Error Detection Process:
Original Data → Generator → Redundant Bits → Data + Redundancy → Transmission → Receiver → Checker → Accept / Reject
At the sender side, a generating function or algorithm calculates the redundant information from the original message. The redundant bits are then appended to the original data and transmitted to the receiver.
At the receiver side, a checking function or algorithm examines the received data and calculates or verifies the redundancy. The result is compared with the expected value.
If the check indicates that the data is correct, the receiver accepts the data. If an error is detected, the receiver rejects or discards the data and may request retransmission depending on the protocol.
Redundancy: Redundancy means adding extra information to the original data so that the receiver can detect or correct transmission errors.
For example, if the sender has a message, it passes the message through a generating algorithm. The algorithm produces redundant bits. These redundant bits are appended to the original message and the complete data is transmitted through the communication medium.
The receiver separates or processes the received information using a checking algorithm. If the calculated check matches the expected check, the data is considered valid. Otherwise, an error is detected.
Error Detection vs Error Correction
Error Detection: Error detection determines whether an error has occurred in the received data. It generally results in a simple decision: Accept if the data is valid or Reject if an error is detected.
Error Correction: Error correction attempts to recover the correct data after detecting an error. It is more complex than simple error detection.
There are two common approaches to error correction:

• Retransmission: The receiver detects an error and requests the sender to retransmit the entire data unit.
• Error-Correcting Code: Additional redundancy allows the receiver to identify and automatically correct certain types of errors without retransmission.

Important: Both error detection and error correction require some form of redundancy because the receiver needs additional information to determine whether the received data is correct and, in some systems, to determine how to correct it.
Error Detection Techniques
There are four commonly discussed error detection techniques in data communication:

• Vertical Redundancy Check (VRC)
• Longitudinal Redundancy Check (LRC)
• Checksum
• Cyclic Redundancy Check (CRC)

1. Vertical Redundancy Check (VRC): VRC is an error detection technique that adds an additional parity bit to a group of data bits. The parity bit is used to make the number of 1s either even or odd, depending on the selected parity scheme. VRC is commonly known as the Parity Check.
2. Longitudinal Redundancy Check (LRC): LRC organizes data into rows and columns and adds redundancy based on the bits in each column. It can detect certain errors that may not be detected by a simple parity check.
3. Checksum: In the checksum technique, the sender divides the data into fixed-size units and performs arithmetic operations on those units to generate a checksum value. The checksum is transmitted along with the data. The receiver performs a similar calculation and compares the result to determine whether an error has occurred.
4. Cyclic Redundancy Check (CRC): CRC is a powerful error detection technique based on binary polynomial division. The sender performs a calculation using a predefined generator polynomial and appends the resulting remainder to the data. The receiver performs a similar calculation to determine whether the received data has been corrupted.
CRC and Checksum are widely used error detection mechanisms in computer networks and communication protocols. CRC is particularly effective at detecting burst errors.

Parity Bit: A parity bit is an additional bit added to a data sequence to detect errors during data transmission. It is the simplest type of error-detecting code.
There are two types of parity: Even Parity and Odd Parity.
Even Parity: The parity bit is selected so that the total number of 1s in the transmitted code, including the parity bit, becomes even.
Example:
Data = 10101
Number of 1s = 3 (odd)
Therefore, parity bit = 1
Transmitted code = 101011
Total number of 1s = 4 (even)
Odd Parity: The parity bit is selected so that the total number of 1s in the transmitted code, including the parity bit, becomes odd.
Example:
Data = 10101
Number of 1s = 3 (odd)
Therefore, parity bit = 0
Transmitted code = 101010
Total number of 1s = 3 (odd)
Error Detection: At the receiver side, a parity checker checks the number of 1s in the received code. If the required parity is not maintained, an error is detected.
Example: Suppose even parity is used and the transmitted code is 101011. If one bit changes during transmission and the receiver gets 101001, the number of 1s becomes 3, which is odd. Therefore, the receiver detects an error.
Important Points:
• Parity can detect odd numbers of bit errors.
• Parity cannot detect an even number of bit errors.
• A parity bit can detect an error, but it cannot identify the exact location of the error.
• Therefore, a simple parity bit cannot correct the error.

What is Checksum?
Checksum is an Error Detection Technique used in computer networks to detect whether data has been corrupted during transmission. At the sender side, the original data is divided into fixed-size blocks, the blocks are added together, and the One's Complement of the final sum is calculated as the checksum. The checksum is then appended to the original data and transmitted to the receiver.
How Checksum Works:

1. Divide the Data: Divide the original message into equal-sized blocks of n bits.
2. Add the Blocks: Add all the blocks using binary addition.
3. Wrap the Carry: If an extra carry is produced, add that carry back to the least significant bit of the result. This is called End-Around Carry.
4. Find One's Complement: Invert every bit of the final sum. 0 becomes 1 and 1 becomes 0.
5. Generate Checksum: The resulting value is the checksum.
6. Append and Transmit: Append the checksum to the original data and send the complete information to the receiver.
7. Receiver Verification: The receiver adds all received data blocks, including the checksum, using the same carry wrap-around method.
8. Accept or Reject: If the final result contains all 1s, the data is considered error-free and accepted. Otherwise, an error is detected and the data is rejected.

Example: Suppose the original data is:
10011001111000100010010010000100
Assume the data is divided into four 8-bit blocks:

10011001

11100010

00100100

10000100

Step 1 — Add the Blocks:

10011001
11100010
00100100
10000100
-----------------
00100011
+     10
---------------
00100101

The resulting 8-bit sum is: 00100101
Step 2 — One's Complement(invert): 00100101→ 11011010 (It is Checksum)
Step 3 — Transmitted Data:
The sender appends the checksum to the original data: 1101101010011001111000100010010010000100
Step 4 — Receiver Verification:
The receiver adds all four data blocks and the received checksum. If the final result is: 11111111
then the receiver assumes that no transmission error has been detected and accepts the data. otherwise rejected.

Performance of Checksum

• Simple and easy to implement.
• Requires relatively little computational overhead.
• Can detect many single-bit, multiple-bit, and burst errors.
• Widely used in network and communication protocols.

Limitation: Checksum cannot detect every possible error. If certain bit errors occur in such a way that their effects cancel each other during the addition, the final checksum may remain unchanged and the error can go undetected.

CRC (Cyclic Redundancy Check) is an error-detection technique used in the Data Link Layer to detect whether data has been corrupted during transmission.
Steps of CRC Process
Choose a Generator Polynomial — Sender and receiver agree on a binary divisor called the Generator.
Append Zeros — Add n-1 zeros to the original data, where n is the number of bits in the generator.
Binary Division — Divide the resulting bit sequence by the generator using XOR division.
Find Remainder — The remainder obtained from the division is called the CRC.
Create Codeword — Append the CRC remainder to the original data.
Transmit — Send the resulting data + CRC to the receiver.

Receiver Checks — Receiver divides the received codeword by the same generator.
Check Remainder:
Remainder = 0 → No error detected.
Remainder ≠ 0 → Error detected.

Shortcut:
Data → Append Zeros → XOR Division → CRC Remainder → Append CRC → Transmit → Divide → Check Remainder