Coursify

CRC Sender-Side and Receiver-Side Steps (with Worked Examples)

CRC Sender-Side and Receiver-Side Steps (with Worked Examples)

Verified Sources
Sep 12, 2026

Cyclic Redundancy Check (CRC ) appends a short checksum (the CRC remainder) to the message. The sender computes the remainder using generator polynomial and modulo-2 division. The receiver recomputes and checks whether the remainder indicates an error. The core theory is: treat message bits as a polynomial over GF(2) and divide by G(x)G(x) to get a remainder. For a properly constructed codeword, the receiver’s final remainder is 00.2

Key idea (common “append zeros then divide” variant):

  • Sender forms W(x)=M(x) xn+R(x)W(x)=M(x)\,x^n + R(x) such that W(x)W(x) is divisible by G(x)G(x); then it transmits the last nn bits as the CRC remainder R(x)R(x).
  • Receiver divides the received codeword W′(x)W'(x) by G(x)G(x) and checks that the remainder is 00 (if not, an error is detected).2

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩ ↩2

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩ ↩2

  3. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

CRC sender/receiver intuition (walkthrough)

Essential terminology for the steps

We’ll use a standard CRC setup:

  • Let G(x)G(x) be the generator polynomial with degree nn (so the CRC remainder has nn bits).2
  • Let MM be the data bits to protect; interpret them as M(x)M(x).
  • Use modulo-2 arithmetic: subtract = XOR in the division process.

Useful keywords introduced here:

  • generator polynomial
  • remainder
  • codeword

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩ ↩2

  2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Sender and Receiver CRC workflow

Sender: prepare dividend

1

Append nn zeros to message to create M(x)xnM(x)x^n"

Sender: compute CRC

2

Modulo-2 divide by G(x)G(x) to get remainder R(x)R(x)"

Sender: transmit codeword

3

Send W=M∣∣RW = M || R (message followed by CRC bits)"

Receiver: recompute remainder

4

Divide received bits by G(x)G(x)"

Receiver: decide

5

If remainder is 00, accept; else detect an error"

Sender-side steps to compute and append CRC

  1. 1
    Step 1

    Both sides must agree on G(x)G(x) (the CRC key). The remainder length equals degree nn of G(x)G(x). 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  2. 2
    Step 2

    Let nn be degree of G(x)G(x). Append nn zeros to the message bitstring to form the dividend M(x)xnM(x)x^n. 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  3. 3
    Step 3

    Divide the dividend by G(x)G(x) using modulo-2 (XOR) polynomial division. The degree of G(x)G(x) ensures the remainder has at most nn bits; take the remainder R(x)R(x). 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

  4. 4
    Step 4

    Append the remainder bits to the original message: W(x)=M(x)xn+R(x)W(x)=M(x)x^n+R(x). Transmit WW as the codeword.

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  5. 5
    Step 5

    If you use a key bitstring for G(x)G(x) (e.g., 1101 represents x3+x2+1x^3+x^2+1), keep bit ordering consistent during division. 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

Receiver-side steps to verify CRC

  1. 1
    Step 1

    Let the receiver obtain W′W' (the transmitted codeword possibly corrupted by channel errors).

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  2. 2
    Step 2

    Perform the same modulo-2 division of W′W' by G(x)G(x).

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  3. 3
    Step 3

    If the remainder is 00, treat the codeword as valid (no detectable error by this CRC). Otherwise, detect an error. 2

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

    2. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

  4. 4
    Step 4

    When remainder is 00, the receiver can discard the last nn CRC bits and use the earlier MM bits as the recovered message.

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Worked Example 1: Sender + receiver using G(x)=1101G(x)=1101 (degree 33), Data = 100100100100

We’ll use the common textbook CRC example where G(x)=1101G(x)=1101 (so n=3n=3) and M=100100M=100100.

  • Degree n=3n=3 ⇒ append 33 zeros to the message to form 100100000100100000.
  • Compute remainder using modulo-2 division to get R=001R=001.
  • Transmitted codeword becomes W=M∣∣R=100100001W = M || R = 100100001.

Sender-side (explicit steps)

  1. Message: M=100100M=100100
  2. Append n=3n=3 zeros: M xn⇒100100000M\,x^n \Rightarrow 100100000
  3. Modulo-2 divide 100100000100100000 by G=1101G=1101 → remainder R=001R=001.
  4. Transmit W=100100001W=100100001.

Receiver-side (explicit steps)

  1. Receiver gets W′W'
    • (No error case) W′=100100001W'=100100001
  2. Divide W′W' by G=1101G=1101
  3. Remainder is 00 → no detectable error.

Error case illustration (single-bit flip concept)

If the channel flips one bit, the receiver may get something like W′=100000001W'=100000001; dividing by GG yields a non-zero remainder, so the receiver detects an error.

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Cyclic Redundancy Check | CRC | Example - Provides the worked example with Data = 100100 and Key 1101, remainder 001, transmitted codeword 100100001, and receiver remainder check (0 for no error). ↩ ↩2 ↩3 ↩4 ↩5 ↩6

Worked Example 2: “Check by re-dividing the received full codeword”

A convenient CRC implementation variant is explicitly described in CRC theory and common practice:

  • If you build the transmitted codeword by appending the correct CRC remainder, then the receiver’s remainder check on the full received codeword should be 00.2
  • This avoids needing to “extract CRC and compare two CRC values” in many hardware implementations. Instead, it just performs the division and checks for zero remainder.

This matches the receiver logic: “divide the received bitstring by G(x)G(x) and check remainder is zero; if so, assume the received message bits are correct.”

Footnotes

  1. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩ ↩2

  2. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

type="tip" title="Pro Tip: Use the “remainder-zeros” property" content="If your sender computes CRC by appending the remainder to the message after dividing (with standard construction), then the receiver can verify by dividing the entire received codeword and checking that the remainder is 00. This is explicitly described as the typical CRC checking approach."2"

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

type="warning" title="Warning: Division must be modulo-2 (XOR) not integer arithmetic" content="CRC polynomial division operates in GF(2). In modulo-2 division, subtraction equals XOR (no borrows/carries like decimal subtraction). If you use normal integer division/subtraction, you’ll get a wrong remainder and mismatched sender/receiver results."2"

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Mini summary table (steps side-by-side)

StageInputOperationOutput / DecisionKey CRC fact
SenderMM and GGAppend zeros; modulo-2 divideCRC remainder RRRemainder has nn bits where n=deg⁡(G)n=\deg(G)2
SenderMM and RRConcatenateTransmitted codeword WWWW is divisible by GG (construction)
ReceiverW′W' and GGDivide W′W' by GGremainder 00 or non-zeroIf remainder is 00, accept; else detect error2

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩ ↩2

  4. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

Common questions about sender/receiver CRC steps

Knowledge Check

Question 1 of 4
Q1Single choice

In the standard CRC construction, if the generator polynomial degree is nn, the sender appends how many zeros to the message before division?

Explore Related Topics

1

Short Notes: YACC

2

Branching Instructions in the 8051 Microcontroller

The 8051 microcontroller uses branching instructions to alter the sequential flow of a program by loading new addresses into the Program Counter, enabling loops, decisions, and sub‑routines.

  • Unconditional jumps (LJMP, AJMP, SJMP, indirect JMP @A+DPTR) differ in address range and size; SJMP/AJMP use 2 bytes versus 3 for LJMP.
  • Conditional jumps (JZ, JNZ, JC, JNC, JB, JNB) depend on accumulator or PSW flags; CJNE also sets the Carry flag for comparisons.
  • DJNZ decrements a register or memory location and loops while the result is non‑zero.
  • SJMP calculates its target by adding a signed 8‑bit offset to the PC after the 2‑byte instruction.
  • AJMP’s 2 KB page limitation requires careful placement to avoid crossing page boundaries.
3

ARP vs RARP: A Comparative Study of Address Resolution and Its Reverse

Browse all research articles