1974-1981

Sequence Numbers

Cut a stream into pieces, number each one where it starts, and the receiver can put them back whatever order they turn up in. That part is obvious. The part that is not is that the number is finite: it runs out and starts again, and at that moment the question which of two segments came first can no longer be answered by asking which number is smaller. The fix is not a bigger number. It is arithmetic on a circle, and a window narrow enough that the answer is never ambiguous.

The stream is in order and nothing underneath it is

1 A stream cut into segments, each one numbered where it starts

A stream cut into segments, each numbered where it starts in the stream.

first sequence number0

seq	carries
0	the␣
4	quic
8	k␣br
12	own␣
16	fox␣
20	jump
24	s␣ov
28	er␣t
32	he␣l
36	azy␣
40	dog

11 segments of 4 bytes, numbered from 0. It does not wrap: the last number is 40.

2 Deliver them in the wrong order and reassemble by number alone

Deliver them in the wrong order. The receiver never learns what order they arrived in — only what each one says about itself.

scrambleshuffle 7

arrived as: 24, 16, 4, 36, 28, 8, 12, 20, …
reassembled: “the quick brown fox jumps over the lazy dog”
same as the stream: yes

Delivered in that order and reassembled from the numbers alone, the stream is byte-for-byte what was sent.

3 Run the number past its maximum and watch a comparison on a line fail

Push the numbering past its maximum and ask which came first. On a line, the answer is wrong for a quarter of all pairs.

numbers in the space: 256
ordered pairs: 65,280
where a < b is wrong: 16,256 (24.9 per cent)
genuinely ambiguous: 256 (exactly 128 apart)

Over every ordered pair of numbers in the space, the two comparisons disagree 16,256 times. That is not an edge case: it is 24.9 per cent of all pairs, and every one of them is a moment where a receiver would put a segment in the wrong place.

4 Compare on a circle instead, and the window that keeps it unambiguous

So compare on the circle instead: a is before b when the forward distance is less than half the space, and nothing is claimed at exactly half.

a	b	a < b	on the circle	forward
10	20	before	before	10
250	4	after	before	10
4	250	before	after	246
200	100	after	after	156
0	128	before	neither	128
128	0	after	neither	128

2 of these 6 ordered pairs are judged differently by the two comparisons, and 2 are refused by the circle entirely: 128 apart is the same distance forward and backward, so both directions of that one pair get no answer.

These ran in this browser when the page loaded. Each claim, whether it held, and the number behind it.

Each claim, whether it held, and the values behind it
claim	held	measured
800 scrambled deliveries reassemble to the same text, including four start points that wrap	yes	order of arrival is not information
on 16,256 of 65,280 ordered pairs, a < b gives the wrong answer	yes	that is 24.9 per cent of them, and every one is a real reordering bug on a real wrap
and 256 pairs are exactly half the space apart, where neither answer is right	yes	the comparison returns nothing for those rather than choosing, which is why a window smaller than half the space is required
254 comes before 2 on the circle and after it on the line	yes	four apart forward, 252 apart backward

What is real here, and what is not

Eight bits, not thirty-two, so the wrap is reachable

TCP numbers bytes in a thirty-two bit space, which at a gigabit takes about half a minute to wrap and is why the protocol has timestamps as well. This page uses eight bits so the wrap happens while you watch. Every statement about the arithmetic holds identically at either width; only the waiting is different.

This is the numbering, not TCP

There is no handshake here, no window advertisement, no retransmission, no congestion control and no state machine. Segments are never lost and never duplicated, which are the two things the numbering exists to survive. What the page models is the comparison, because that is the part that stops being obvious when the counter wraps.

Half the space is genuinely ambiguous, and refusing is a choice this page made

When two numbers are exactly half the space apart, neither is before the other in any useful sense: the forward distance and the backward distance are equal. This page returns nothing for those pairs rather than picking one. That is a decision, not a rule inherited from the standard, and an earlier version of this entry said otherwise. RFC 1982 leaves the case undefined and is explicit about what that permits: implementations are “free to return either result, or to flag an error, and users must take care not to depend on any particular outcome. Usually this will mean avoiding allowing those particular pairs of numbers to co-exist.” Free to return either result, so an implementation that guesses is conforming and this one is stricter than it has to be. The entry that stood here until 2026-08-22 credited the RFC with mandating a receiver window smaller than half the sequence space. The archived RFC contains no occurrence of the word window, or half, or MUST; the window constraint is real and belongs to TCP rather than to this document. An outside reader caught the attribution.

Sources

Logical Art builds interactive explanations of difficult machines.

The machines:

1935-1991 RangekeeperThe answer is on both sides of the equation, so it had to be a machine.
1964-1990s AbendThe loop you did not write, and the day it cost to get it wrong.
1971-1995 Line ModeYou could telnet to port 80 and be the browser, and then you could not.
1975 Front PanelA working 1975 Altair 8800 you program by flipping switches.
1980s 300 BaudA real dial-up modem and the BBS on the other end of it.
1994 WinsockThe two seconds after the modem stopped screeching, before anything worked.
2020s LLM LabTrain a tiny language model and watch every number as it learns.

Smaller pieces, on the studio itself: Morse, Baudot, Flip-Flop, Punch Cards, Interlace, Bitwise, The Adder, Stored Program, Two's Complement, Trigger, Bit, Nibble, Byte, Transistor, The Middle Square, Score Reel, Hamming, Huffman, Core Memory, Hash Table, The Interrupt, CORDIC, The Call Stack, Garbage, CRC, The Pipeline, Round Robin, Page Fault, Context Switch, ASCII, The Shuffle, Packet Switching, Bresenham, CPU Cache, Deadlock, Race, Fifteen Planes, B-tree, Bloom Filter, Double Buffer, Avalanche, Backoff, Checkout, Sequence Numbers, Compare and Swap, Diffie-Hellman, Dithering, Zero Address, Fringes, LZ77, Signature, Logical Clock, Z-Characters, Merkle Proof, Branch Prediction, Write-Ahead Log, Interleave, Eight Sprites, DNS, LZW, Floating Point, Slow Start, RAID Parity, Longest Chain, JPEG, UTF-8, Masking, PageRank, AES, Merge Collapse, Merkle DAG, Count Distinct, Majority.

A Logical Art machine by RoamingPigs, Inc. Built by Cisco Caceres in Las Vegas, NV.