What does a is congruent to b mod n mean?

a is congruent to b modulo n, written a equivalent b mod n, means that a and b leave the same remainder when divided by n. Equivalently, n divides the difference a minus b. For example, 14 is congruent to 2 mod 12 because both leave remainder 2 when divided by 12.

What is the zero class in modular arithmetic?

The zero class mod n is the set of all integer multiples of n. It is sometimes called the principal class because it is the identity element of the ring of integers mod n, the kernel of the canonical map from the integers to that ring, and the only class whose members are divisible by n.

How many equivalence classes are there mod n?

There are exactly n equivalence classes mod n, labeled by their remainders 0, 1, 2, ..., n minus 1. Every integer belongs to exactly one class, and two integers belong to the same class if and only if their difference is a multiple of n.

Where is modular arithmetic used in real life?

Clock arithmetic is modulo 12 or 24, day-of-week calculations are modulo 7, and parity (even versus odd) is modulo 2. Modular arithmetic also underlies most of modern cryptography including RSA and Diffie-Hellman, hashing functions in computer science, check digits on credit cards and ISBNs, and the construction of finite fields used in error-correcting codes.

Modular Wheel

How to use

Count up to sets how many integers a run places, from $1$ up to the cap printed under the box as max for divisor n; a larger value shows a red message and disables ▶ Run. Learn more about the count
The Divisor grid picks $n$ from $2$ to $9$ ; the wheel is re-divided into $n$ slices at once and any run is cleared. Learn more about the divisor grid
The Speed slider, from 🐢 to 🐇, sets the time per number, about $365$ ms at $1$ and $50$ ms at $10$ ; a run keeps the speed it started with. Learn more about the speed slider
▶ Run places $1, 2, 3, \dots$ one per tick and turns into ⏹ Stop, which halts the run; Reset clears the wheel and any pinned class. Learn more about the run controls
The wheel has one slice per remainder, $0$ starred at the top and the rest clockwise; rows fill outward from the centre, and the hub reads mod n. Learn more about the wheel and slices
Hover or tap a slice to see its class: a tooltip gives the formula and examples, the right panel lists the numbers placed there, and a tap pins it until you tap again. Learn more about hovering and pinning
The starred slice $0$ holds the multiples of $n$ , the only class where divisibility by $n$ holds. Learn more about the zero class
The right panel switches between Overview, Now placing, Class details and Run complete, which lists the divisible numbers and the count per class. Learn more about the right panel

Numbers grouped by their remainder when divided.

👆Tap or hover any slice for details

★ 0 (zero class)

r=1

r=2

r=3

r=4

r=5

Overview

You're looking at the integers 1, 2, 3, … sorted by their remainder when divided by 6.

Press ▶ Run to watch each number find its slice. Tap a slice anytime to see what it represents.

The wheel is set: one slice per remainder class, the zero class starred at the top. Press Run and the integers will sort themselves. Learn more about getting started · Panel modes

What is modular arithmetic?

Modular arithmetic asks one question about a whole number: what's the remainder when you divide by n? The answer is always between 0 and n−1.

We say "a is congruent to b modulo n" — written a ≡ b (mod n) — when a and b leave the same remainder. It's the math behind clocks (mod 12), days of the week (mod 7), and most of modern cryptography.

Equivalence classes

For a fixed divisor n, the integers split into exactly n groups by remainder. Class 0 collects the multiples of n. Class 1 collects 1, n+1, 2n+1, …. And so on, up to class n−1.

Every integer belongs to exactly one class. Two numbers in the same class are always n apart on the number line — that periodicity is the whole point. The wheel makes it visible: each slice is one class, and rows fill from the center outward as the count progresses.

★ The zero class — why it's special

Class 0 — the multiples of n — sits at the top of the wheel and gets a gold outline. It's the principal class: the identity element of the structure ℤ/nℤ.

Why it stands out:

It's the only class containing 0.
It's the only class where "divisible by n" is true.
Every other class is just this one shifted by 1, 2, …, or n−1.
In ring theory, it corresponds to the principal ideal nℤ.

How to read this wheel

Each slice is one remainder class. The label outside (0, 1, 2, …) tells you which remainder.
Inside each slice, numbers stack outward — row 1 (closest to center) holds the first occurrence, row 2 the second, and so on.
Tap or hover any slice for its formula and example numbers.
Slice 0 is centered at 12 o'clock to emphasize it as the principal class.

Try this

Run with divisor 2 — even and odd numbers split into two halves of the wheel.
Run with divisor 5 — numbers ending in the same digit, or in digits five apart (like 3 and 8), share a slice.
Switch divisors after running — the same numbers exist, but the class structure changes completely.
Pick a small max with a large divisor (e.g. 12 with divisor 7) — most classes get one or two numbers; that's enough to see the pattern.

Key Terms

Getting Started

The Wheel and Slices

Run Controls and Speed

Hovering and Pinning Classes

The Zero Class — Why It's Special

Adjusting Divisor and Count

Right Panel Context

Reading a Complete Run

What Is Modular Arithmetic

Equivalence Classes and Their Structure

Related Concepts

Key Terms

Modular arithmetic — arithmetic on remainders. Given a divisor (or modulus)

n

, every integer is replaced by its remainder when divided by

n

, an integer in the range

\{0, 1, \dots, n - 1\}

.

Modulus / divisor

n

— the integer you divide by. On this tool,

n

ranges from

2

9

(the slice count).

Remainder — the leftover after integer division. For

a = qn + r

with

0 \leq r < n

, the remainder is

r

, written

a \bmod n = r

.

Congruence

a \equiv b \pmod n

— read

a

is congruent to

b

modulo

n

. True when

a

and

b

leave the same remainder when divided by

n

, equivalently when

n

divides

a - b

.

Equivalence class / residue class — the set of all integers sharing the same remainder. There are exactly

n

classes mod

n

, labeled

[0], [1], \dots, [n - 1]

.

Zero class (principal class) — the class

[0]

, containing

0

and all multiples of

n

. It's the identity element of the ring

\mathbb{Z}/n\mathbb{Z}

and corresponds to the principal ideal

n\mathbb{Z}

. The tool highlights this class with a gold star and warm color.

\mathbb{Z}/n\mathbb{Z}

— the integers mod

n

, the set of

n

equivalence classes with addition and multiplication inherited from

\mathbb{Z}

Getting Started

The tool opens with divisor

n = 6

and a count target of

36

. The scene splits into three areas:

• A control panel on the left with inputs for the count target, the divisor (a button grid for

n = 2

through

9

), a speed slider, and Run / Stop / Reset buttons.

• A circular wheel in the middle, divided into

n

equal slices. Each slice is one remainder class. The zero class sits at the top (12 o'clock) marked with a gold star ★.

• A context panel on the right that switches modes depending on what's happening: an overview before running, a now placing log while running, a class details card when you hover or pin a slice, and a run complete summary at the end.

To run:

• Set the count target — the number of integers to sort (1 through that target).

• Pick a divisor in the grid.

• Press ▶ Run — numbers

1, 2, 3, \dots

appear one at a time, each placed in its remainder slice with rows filling outward from the center.

• Hover or click a slice to see its formula, examples, and any numbers already placed there.

• Reset to clear and try a different combination.

mod 6, idle, frozen

Six empty slices around the mod 6 hub, the zero class starred at twelve o’clock. Nothing is placed yet — the wheel is pure structure.

The frozen frame above is the idle wheel: six empty slices around the mod 6 hub, structure without content. Even empty, it already says something — the modulus alone fixes how many classes exist, before a single number is sorted.

Idle is also the state to read the geometry in: slice labels outside, row arcs faint inside, and the starred zero slice at twelve o'clock. Once Run is pressed, the wheel anatomy fills in exactly these positions.

The Wheel and Slices

The wheel divides a circle into

n

equal slices, one per remainder class. Five things to watch:

• Slice labels outside each slice show the remainder value:

0

at the top, then

1, 2, \dots, n - 1

going clockwise.

• Slice colors use a blue palette so the zero class can stand apart. The zero slice has a warmer fill and a thin gold accent arc along its outer edge.

• Rows within each slice run from the center outward — row

1

is closest to the center, row

2

above it, and so on. Each row holds the next occurrence of that class.

• Numbers in cells are drawn rotated so they always read upright relative to the slice they sit in. A label like *36* in slice

0

row

6

tells you

36 = 6 \cdot 6 + 0

, the sixth multiple of

6

.

• Center label shows mod

n

— the modulus currently in effect.

Cells are placed in real time as the run progresses. The geometry adapts to the available width: bigger screens get a larger wheel with taller rows; smaller screens compress the row height. The control panel shows a max-count cap for the current divisor — going beyond it would make labels unreadable.

Run Controls and Speed

DemoRun, Stop, Speed and Reset

Step 0 of 4

The control panel offers three transport actions and a speed slider:

• ▶ Run — starts placing numbers from

1

up to the count target, one per tick. Disabled while the input is invalid (empty, non-numeric, below

1

, or above the geometric max).

• ⏹ Stop — halts placement at the current number. The wheel keeps what's there; press Run again to start fresh from

1

.

• Reset — clears all placed cells, unpins any class, and restores the idle state.

• Speed slider with tortoise 🐢 and hare 🐇 markers controls the tick delay. The tick interval is roughly

\max(20, 400 - 35 \cdot \text{speed})

milliseconds — at speed

1

each number takes about

365

ms; at speed

10

each takes about

50

ms.

While running, the right panel switches into now placing mode (the right panel) and shows live arithmetic for the most recent number:

n \div d = q

remainder

r

, and which slice and row it just landed in. Numbers in the zero class get extra emphasis to call out the divisibility.

mod 6, placing 17, frozen

Seventeen numbers in: 17 ÷ 6 = 2 remainder 5, so 17 has just landed in class 5, row 3 — the third number to leave that remainder.

The frozen frame above catches a run mid-flight: seventeen numbers placed, and the log reporting

17 \div 6 = 2

remainder

5

— so 17 has just landed in class 5, row 3. Rows count occurrences: 17 is the third number (after 5 and 11) to leave remainder 5.

Watching a few ticks makes the rhythm obvious: the placement simply walks around the wheel, one slice clockwise per number, wrapping back to the starred slice at every multiple. That steady rotation is the additive structure of equivalence classes in motion.

Hovering and Pinning Classes

DemoPinning a class

Step 0 of 4

Every slice on the wheel is interactive:

• Hover any slice — a floating tooltip appears showing the class title, formula, description, and example numbers. The right panel simultaneously switches into class details mode with the same information plus the list of numbers already placed in that class.

• Click to pin the class — the tooltip stays put, the slice darkens slightly, and the right panel keeps showing details until you click somewhere else (or click the same slice again to unpin).

• Click anywhere outside any slice to clear the pin.

The tooltip layout adapts to viewport edges — it flips to the left of the cursor when too close to the right edge and above when too close to the bottom. Pinned tooltips show a *📌 Pinned* indicator at the bottom; hover-only tooltips show Tap to pin.

The class details panel includes:

• The formula —

n = nk

for class

0

, or

n = nk + r

for class

r

.

• A list of first

8

examples of integers in the class.

• A Placed so far block listing every number from the current run that landed in this class, if any.

mod 6, class 2 pinned, frozen

The darkened slice collects 2, 8, 14, 20, 26, 32 — every number of the form 6k + 2, each exactly six apart.

The frozen frame above has class 2 pinned after a full run of 36: the darkened slice holds 2, 8, 14, 20, 26, 32 — six numbers, each exactly six apart. Pinning turns one wedge of the wheel into a statement: this is a single residue class, an arithmetic progression wrapped into a slice.

Pinning is also the way to compare classes: pin one, read its members, then pin its neighbor and watch every number shift by exactly one. The only slice that answers differently is the starred one — see the zero class.

The Zero Class — Why It's Special

Class

[0]

— the multiples of

n

— gets special visual treatment: it's centered at

12

o'clock, marked with a gold star ★, outlined with a warm-gold accent arc, and labeled prominently in the legend.

The emphasis is mathematical, not cosmetic. The zero class is the principal class:

• It contains the integer

0

, which is the additive identity of

\mathbb{Z}/n\mathbb{Z}

.

• It's the only class where divisibility by

n

is true — every member is an exact multiple of

n

.

• Every other class is the zero class shifted: class

[r] = [0] + r

.

• In ring theory it corresponds to the principal ideal

n\mathbb{Z}

.

• It's the kernel of the canonical map

\mathbb{Z} \to \mathbb{Z}/n\mathbb{Z}

— the integers that get sent to

0

under modular reduction.

For applications, the zero class is what you test for divisibility, what triggers modular conditions like check if

n

is a multiple of

7

, and what determines whether a number has a multiplicative inverse in

\mathbb{Z}/n\mathbb{Z}

(nonzero residues coprime to

n

do; zero never does).

mod 6, zero class pinned, frozen

The gold-edged slice holds 6, 12, 18, 24, 30, 36 — the multiples of 6, the only class where divisibility is true.

The frozen frame above has the principal class pinned after a full run: 6, 12, 18, 24, 30, 36 sit in the gold-edged slice — the multiples of 6, and nothing else. Every divisibility question about 6 is a question about membership in this one slice.

The gold styling repays attention during a run, too: each time the placement crosses twelve o'clock, the number landing there is exactly a multiple of the modulus, and the now placing log flags it. Divisibility stops being a property you compute and becomes a place on the wheel.

Adjusting Divisor and Count

DemoDivisor and count

Step 0 of 5

Two inputs control the size and shape of the wheel:

• Count up to sets the upper bound of the integers placed during a run. Range starts at

1

and is capped per divisor by a geometric maximum — the cap ensures rows fit at the minimum readable cell height. The cap appears below the input as max for divisor

n

: M. Common caps at default width: divisor

2

allows roughly

80

numbers, divisor

9

allows much more since rows are spread across more slices.

• Divisor (number of slices) is an eight-button grid for

n = 2, 3, 4, 5, 6, 7, 8, 9

. Picking a new divisor immediately clears any in-progress run and re-divides the wheel. The wheel resizes and re-labels each slice.

Try these comparisons:

• Divisor

2

— split into even and odd halves. Class

0

= evens, class

1

= odds.

• Divisor

5

— slice

r

holds every integer whose last digit is

r

r + 5

. The closest this wheel gets to reading off last digits directly (a mod-

10

wheel would do it exactly, but the divisor grid stops at

9

).

• Divisor

7

— counting from

1

takes seven numbers to complete one row across all slices. Mimics the day-of-week shift.

• Same number, different divisors — keep the count fixed at

30

and step through divisors

2

9

to see how class sizes change.

mod 2, 20 placed, frozen

Two half-circles: evens in the starred half, odds opposite, ten each. Parity is the smallest modulus, drawn as a coin with two faces.

The frozen frame above is the divisor-2 wheel after counting to 20: two half-circles, evens in the starred half, odds opposite, ten numbers each. Parity — the oldest classification in arithmetic — is just modular arithmetic at its smallest modulus, and the wheel draws it as a coin with two faces.

Changing the divisor is the tool's most instructive move: the same integers exist either way, but the wheel repartitions them completely. Nothing about a number changes; only the question asked of it does. How the classes balance out at the end of a run is taken up under reading a complete run.

Right Panel Context

The right panel adapts to whichever phase the visualization is in:

• Overview (idle) — appears before the first run. Confirms which divisor is selected and prompts you to press Run.

• Now placing (running) — shows the most recent number, its division arithmetic (

n \div d = q

remainder

r

), which class it landed in, and which row within that class. Zero-class hits get a divisible by

n

accent.

• Class details (hover/pin) — appears whenever a slice is hovered or pinned. Shows the formula, first eight examples, and any run-placed numbers in this class.

• Run complete (summary) — appears after the count target is reached. Lists the divisible numbers in the zero class as the headline, then a grid showing the count per class.

Below the adaptive box sits a static deep-dive section with five collapsible-looking subsections: What is modular arithmetic, Equivalence classes, *The zero class — why it's special*, How to read this wheel, and Try this. These are always available and don't change with state — they're reference material to read alongside experimenting on the wheel.

Reading a Complete Run

DemoReading a complete run

Step 0 of 4

When the last number lands, the right panel switches to its run complete summary: the divisible numbers — the contents of the zero class — as the headline, then a small grid counting the members of every class.

For the default run of

36

with divisor

6

, the wheel finishes perfectly balanced: six full rows in every slice, exactly six numbers per class. That is no accident —

36

is a multiple of

6

, so the count 1 through 36 completes whole laps of the wheel.

The counts can never be lopsided by much. Counting

1

through

N

deals numbers to the slices in strict rotation, so any two classes differ by at most one member.

mod 6, run complete, frozen

All 36 numbers placed: six full rows in every slice, six per class — perfectly balanced, because 36 is a multiple of 6.

The near-balance has a precise form. Write

N = qn + r

; then classes

1

through

r

hold

q + 1

numbers and the rest hold

q

. Try counting to

20

with divisor

6

: classes 1 and 2 collect four members, every other class three — and the zero class gets exactly

\lfloor 20/6 \rfloor = 3

, namely 6, 12, 18.

This is the pigeonhole picture of equivalence classes:

n

boxes, dealt in rotation, can never be unfair by more than a single card. Change the divisor and rerun to watch the same fairness reassert itself over different slices.

What Is Modular Arithmetic

Modular arithmetic replaces each integer with its remainder when divided by a fixed modulus

n

. The result is always one of

\{0, 1, \dots, n - 1\}

, no matter how big the input.

The fundamental notation is congruence:

a \equiv b \pmod n \iff n \mid (a - b)

That is,

a

and

b

are congruent modulo

n

when their difference is a multiple of

n

, equivalently when they leave the same remainder.

Examples:

• Clock arithmetic is mod

12

(or mod

24

14

o'clock

\equiv 2

o'clock

\pmod{12}

.

• Days of the week are mod

7

. If today is Wednesday, day

100

from now is Wednesday

+ 100 \bmod 7 =

Wednesday

+ 2

= Friday.

• Parity is mod

2

. Even means

\equiv 0 \pmod 2

; odd means

\equiv 1 \pmod 2

.

• Cryptography — RSA, Diffie-Hellman, elliptic-curve protocols all operate in

\mathbb{Z}/p\mathbb{Z}

\mathbb{Z}/n\mathbb{Z}

for very large

n

.

• Hashing and indexing — converting arbitrary integers into a fixed range

\{0, \dots, n - 1\}

is exactly modular reduction.

The operations of addition, subtraction, and multiplication on classes are well-defined:

(a + b) \bmod n = ((a \bmod n) + (b \bmod n)) \bmod n

, and likewise for multiplication. Division (modular inverse) exists only when

\gcd(a, n) = 1

.

For deeper coverage, see the modular arithmetic section on the number theory page.

Equivalence Classes and Their Structure

For a fixed modulus

n

, the integers

\mathbb{Z}

split into exactly

n

disjoint equivalence classes:

\mathbb{Z} = [0] \sqcup [1] \sqcup \dots \sqcup [n - 1]

The square cup

\sqcup

is a union carrying a promise: it is written in place of

\cup

precisely when the pieces are known to be disjoint, so the line asserts both that the classes cover

\mathbb{Z}

and that they never overlap. Ordinary

\cup

would be equally true here and would say less.

Each class

[r]

is the set

\{r + kn : k \in \mathbb{Z}\}

— an infinite arithmetic progression spaced

n

apart on the number line.

Properties:

• Every integer belongs to exactly one class.

• Two integers are in the same class iff they're congruent mod

n

.

• Class

[r]

contains negative numbers too:

-7 \equiv 5 \pmod{12}

because

-7 + 12 = 5

.

• Class sizes are infinite in

\mathbb{Z}

; on the wheel they look finite only because we cut the count at the target.

The set of classes is a ring. Define

[a] + [b] = [a + b]

and

[a] \cdot [b] = [a \cdot b]

on representatives, then check the result doesn't depend on which representatives you picked. The result is the ring

\mathbb{Z}/n\mathbb{Z}

:

• Always associative, commutative, with multiplicative identity

[1]

.

• A field exactly when

n

is prime — then every nonzero class has a multiplicative inverse.

• When

n

is composite, some classes are zero divisors: nonzero

[a], [b]

with

[a] \cdot [b] = [0]

. For instance, in

\mathbb{Z}/6\mathbb{Z}

[2] \cdot [3] = [6] = [0]

.

The wheel visualizes the additive structure: shifting all numbers by

+1

rotates everything one slice clockwise. Multiplicative structure is harder to picture but underlies most applications.