Ducci Sequence¶

An orbit of a cyclic integer tuple under repeated replacement by the absolute differences of adjacent entries, studied through its transient, zero-reaching, and periodic behavior.

Version: v2 · 2026-09-19 · History
Domain-specific #: 1725
Domain group: Formal Sciences
Origin domain: Mathematics
Subdomains: Discrete Mathematics, Integer Dynamical Systems → Mathematics
Aliases: Ducci map, N-number game, Diffy game

Core Idea¶

A Ducci Sequence is the orbit produced by repeatedly applying one fixed difference operation to a cyclic tuple of integers. For a tuple (a1, a2, ..., an), form the next tuple as (|a1-a2|, |a2-a3|, ..., |an-a1|). The last and first entries are neighbors, so the operation wraps around. Iterating that map creates a discrete dynamical system whose salient questions concern the transient before repetition, arrival at the all-zero tuple, and the length and form of eventual cycles.^[1]

The locked identity is finite ordered integer tuple + cyclic adjacency + coordinatewise absolute differences + repeated application of the same map -> a Ducci orbit. Each element alone is too broad. Ordinary finite differences normally operate along a line rather than a circle; an isolated difference tuple is not yet a sequence; and an arbitrary recurrence does not use the Ducci operator.

For integer inputs, translation by a common constant disappears after one step, scaling all entries by a nonnegative integer scales the entire orbit, and the range cannot increase. These facts let one normalize many questions. Because every later coordinate lies between zero and the original range, an integer orbit occupies a finite state set and must eventually repeat. Periodicity is therefore a structural consequence of bounded integrality, not merely an empirical pattern. Stronger claims depend on tuple length and coefficient domain: the familiar theorem that every orbit reaches zero when n is a power of two does not license the same conclusion for every n or for real-valued generalizations.^[2]

How would you explain it like I'm…

The Circle Subtraction Game

Write some numbers in a circle. Under each pair of neighbors, write how far apart they are, going all the way around so the last number and the first number are neighbors too. Then do it again with the new numbers, and again. Sometimes they all turn into zeros, and otherwise a pattern starts repeating.

Differences Around a Circle

A Ducci sequence starts with a list of whole numbers arranged in a circle, so the last number is next to the first. To make the next list, you take the difference between each neighbor pair and ignore minus signs. For example, 1, 5, 2, 8 becomes 4, 3, 6, 7, then 1, 3, 1, 3, then 2, 2, 2, 2, then 0, 0, 0, 0. Because the numbers can never get bigger than the biggest gap you started with, the lists must eventually repeat. When the list has 4 or 8 or 16 numbers, it always ends at all zeros, but with other lengths it can get stuck in a repeating loop instead.

Iterated Cyclic Difference Map

A Ducci sequence comes from repeatedly applying one rule to a list of integers arranged in a cycle: (a1, a2, …, an) becomes (|a1 − a2|, |a2 − a3|, …, |an − a1|), where the last entry wraps around to the first. Doing this again and again is a simple dynamical system, and the questions are how long it takes to start repeating, whether it reaches all zeros, and what repeating cycles look like. Some basic facts help: adding the same number to every entry disappears after one step, multiplying every entry by a nonnegative integer multiplies the whole sequence, and the gap between largest and smallest never grows. Since every later entry lies between zero and the original range, there are only finitely many possible lists, so the sequence must eventually repeat. If the length n is a power of two, it always reaches zero, but that isn't true for other lengths or if you allow real numbers.

A Ducci sequence is the orbit of a cyclic integer tuple under the Ducci map D(a1, ..., an) = (|a1 - a2|, |a2 - a3|, ..., |an - a1|), where the cyclic adjacency makes the last and first entries neighbors. Iterating D defines a discrete dynamical system whose central questions concern the transient before repetition, arrival at the zero tuple, and the length and form of eventual cycles. The identity requires all four ingredients: a finite ordered integer tuple, cyclic adjacency, coordinatewise absolute differences and repeated application of the same map; ordinary finite differences along a line, a single difference tuple or an arbitrary recurrence are different objects. Several invariances simplify analysis: adding a common constant to all entries is erased after one step, scaling by a nonnegative integer scales the whole orbit, and the range never increases. Because every subsequent entry lies between zero and the original range, the orbit lives in a finite state set and must eventually become periodic, a structural consequence of bounded integrality rather than an observed pattern. Stronger conclusions depend on n and the coefficient domain: every orbit reaches zero when n is a power of two, but this does not carry over to other n or to real-valued versions.

Structural Signature¶

state: an ordered n-tuple, normally of integers;
boundary condition: the entries are arranged cyclically, making an adjacent pair of an and a1;
update operator: every coordinate becomes the absolute difference of one adjacent pair;
synchronous replacement: all new coordinates are computed from the same old tuple;
iteration: the output becomes the next input without changing the rule;
orbit: the initial tuple, transient states, and eventual attractor are considered together;
zero state: the all-zero tuple is a fixed point;
periodic state: a nonzero state may enter a cycle, often understood up to a common scale or normalization;
length parameter: n materially changes the permitted dynamics;
coefficient domain: integers, residues modulo m, rationals, and reals produce related but nonidentical systems;
normalization: translation, scaling, maximum, gcd, or parity may simplify analysis without replacing the original map;
questions of interest: stopping time, transient length, cycle length, reachability, and classification of orbits.

The recognition test is operational: write the tuple around a circle, replace all neighboring pairs simultaneously by their unsigned differences, and repeat. If a proposed example changes signs rather than taking absolute values, omits the wraparound pair, updates in place, or changes the operator between steps, it is a neighboring difference process rather than the standard Ducci Sequence.

What It Is Not¶

Not any sequence formed by subtraction. The cyclic, synchronous, absolute-difference map is indispensable.
Not a finite-difference table. Forward differences on polynomial values use linear adjacency and usually reduce row length.
Not the Euler sequence. Eulerian or Euler-number sequences have distinct generating rules and mathematical objects.
Not the Collatz map. Both invite orbit questions, but their state spaces and update operators are unrelated.
Not merely a cellular automaton. Parity reduction can connect the map to binary cellular rules, but the integer magnitudes are part of the original system.
Not guaranteed to reach zero for arbitrary tuple length. Some lengths admit nonzero periodic behavior.
Not unchanged when generalized to real inputs. Boundedness no longer implies recurrence in a finite state space.
Not an asynchronous game. Choosing one edge at a time defines a different process.
Not a universal abstraction of iteration. Iteration is its reusable parent mechanism; the Ducci identity remains mathematical and operator-specific.

Scope of Application¶

The primary scope is discrete mathematics and the study of elementary dynamical systems. A small rule generates nontrivial global behavior, making the map useful for questions about invariants, periodicity, parity, modular reduction, and dependence on dimension. The map also appears as the n-number game or Diffy game in mathematical recreation and education, where learners can calculate short orbits by hand and then formulate conjectures.

Research extends the rule to vector spaces over the two-element field, residue rings, and real vector spaces. These variants can reveal algebra hidden by the absolute-value presentation, but their conclusions must be stated with the coefficient domain attached. Chamberland, Thomas, and Ladas formulate the Ducci map on binary and real vector spaces and identify open questions about transient and cyclic behavior.^[1] Chamberland's work on unbounded real Ducci sequences demonstrates why integer finiteness cannot be silently transferred to the real setting.^[3]

The node is not a claim that the puzzle is practically deployed outside mathematics. Its value lies in naming a recurring mathematical object and family of problems rather than a single historical exercise.

Clarity¶

Two conventions need explicit control. First, “sequence” can mean the entire orbit, while an individual object is an n-tuple. Second, cycle statements may be literal or normalized. Because multiplying an initial tuple multiplies every future tuple, infinitely many numerically distinct cycles can represent the same shape at different scales. Authors sometimes reduce by a common factor, take parity, or work modulo an integer before classifying cycles. A reference-grade claim must say which equivalence is used.

For example, starting from (1, 5, 7, 9) gives (4, 2, 2, 8), then (2, 0, 6, 4), then (2, 6, 2, 2), and so on until zero. The calculation uses old coordinates simultaneously. Replacing the first coordinate and then using that new value to compute the second would give another orbit.

Manages Complexity¶

The named abstraction compresses a full experimental specification. “Apply the Ducci map” communicates the state shape, circular topology, local operator, synchronization, and iterative regime. Researchers can then focus on the property being compared rather than restating the recurrence.

It also separates levels of explanation. Local differences determine one update; invariants and finite-state arguments explain eventual behavior; algebra over finite fields can explain dependence on n; computation can enumerate cases. Without the shared identity, observations about cycles, stopping times, and modular versions look like unrelated puzzles.

Abstract Reasoning¶

Adding the same integer c to every coordinate does not affect the first difference tuple, because common translation cancels.
Multiplying all entries by a nonnegative integer k multiplies all subsequent entries by k, permitting scale-normalized comparison.
Each new coordinate is no larger than the preceding tuple's range, so an integer orbit remains bounded.
A bounded integer state space with deterministic update must eventually revisit a state and thereafter be periodic.
Reaching the zero tuple terminates the dynamics because zero maps to itself.
If a theorem assumes n is a power of two, applying it to six or ten entries requires a new argument.
Reducing an orbit modulo two can expose parity dynamics while discarding magnitude; a parity proof must reconnect to the integer claim.
A nonzero cycle disproves universal zero convergence for its tuple length but says nothing by itself about other lengths.
An unbounded real orbit does not contradict boundedness of integer orbits because the finite-state premise has changed.
Computational enumeration supports a conjecture only over the searched state and normalization range.

Knowledge Transfer¶

The transferable skeleton is finite state + local synchronous map + iteration -> orbit classification. That structure can guide analysis of cellular automata, chip-firing systems, and other recurrence maps. The Ducci name should transfer only when cyclic absolute differences remain the update rule. If the local function, topology, or coefficient semantics changes, the new system may be inspired by Ducci sequences without being one.

The most useful general lesson is methodological: distinguish a theorem caused by the operator from one caused by the coefficient domain. Finite-state recurrence is not a property of iteration alone; it emerges from determinism, boundedness, and discrete values together.

Examples¶

four-number game: an integer 4-tuple repeatedly differentiated around a circle eventually reaches zero;
non-power-of-two length: an orbit enters a nonzero periodic cycle, demonstrating the length boundary on zero convergence;
translated start: adding 100 to every initial entry yields the same tuple after the first update;
scaled start: doubling each coordinate doubles every tuple in the orbit;
binary reduction: parity states are studied as a linear map over the two-element field;
real generalization: a real tuple follows the same formal update but can exhibit behavior excluded by finite integer-state reasoning;
non-example—linear differences: computing adjacent differences without the last-to-first edge is not the standard map;
non-example—in-place update: replacing entries one at a time violates synchronous evolution.

Structural Tensions¶

elementary rule vs. difficult dynamics — hand calculation is simple while global orbit classification remains subtle;
finite-state certainty vs. stopping uncertainty — eventual repetition follows easily, but whether repetition is zero can depend delicately on n;
literal cycles vs. scale classes — homogeneity simplifies analysis while obscuring what counts as the same orbit;
integer theorem vs. real extension — identical notation can conceal loss of finiteness and bounded-state arguments;
computation vs. proof — enumeration finds cycles and patterns but does not establish unrestricted claims;
recreational accessibility vs. research precision — the game invites experimentation, while publication requires exact conventions.

Structural–Framed Character¶

Ducci Sequence is structural inside mathematics. Its identity is fixed by a formal state space and update map, not by institutional choice or evaluation. The eponym and game names are framed labels; the orbit exists independently of them.

Structural Core vs. Domain Accent¶

The structural core is cyclic state + local difference rule + synchronous iteration. The domain accent is integer tuples, absolute value, modular and parity analysis, and the theorems controlled by n. Removing that accent yields generic Iteration or a discrete dynamical system, not the named abstraction.

This entry is part of Iteration.

Iteration — the same operator is repeatedly applied to its own output.
Sequencing — states are ordered by update time.
Feedback — each output becomes the full next input.
Periodicity — repeated states organize long-run behavior.
Invariant — translation, scale relations, and bounded quantities constrain the orbit.

Iteration is load-bearing, but a Ducci sequence is not simply any iterated process.

Relationships to Other Abstractions¶

Current abstraction Ducci Sequence Domain-specific

Parents (1) — outgoing typed relations

Ducci Sequence includes Iteration Prime

the same operator is repeatedly applied to its own output.

Hierarchy path (1) — routes to 1 parentless root

Ducci Sequence → includes Iteration

Neighborhood in Abstraction Space¶

Ducci Sequence sits in a sparse region of the domain-specific corpus (87^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Unclustered & Miscellaneous (2769 abstractions)

Nearest neighbors

Temporal logic of actions — 0.82
Firing-Squad Synchronization Problem — 0.81
Multiplicative Digital Root — 0.80
Indiscernibles — 0.80
Isolating Neighborhood — 0.80

Computed from structural-signature embeddings · 2026-10-25

Not to Be Confused With¶

Euler sequences or Euler numbers;
forward, backward, or divided differences;
the Collatz conjecture and related integer maps;
arbitrary n-tuple recurrences;
Rule 102 or another binary cellular automaton without an explicit parity correspondence;
cyclic sequences that lack absolute subtraction;
normalized orbit classes presented as literal integer equality;
the historical discoverer rather than the mathematical map.

References¶

[1] Marc Chamberland, Diana M. Thomas, and Gerry Ladas, “The N-Number Ducci Game,” Journal of Difference Equations and Applications 10(3) (2004), 339–342, https://doi.org/10.1080/10236190410001647807. registry ↩a ↩b

[2] Marc Chamberland, “The Ducci Map and Its Generalizations,” survey bibliography and exposition, https://chamberland.math.grinnell.edu/papers/ducci_survey.pdf. registry ↩ Show verification details

[3] Marc Chamberland, “Unbounded Ducci Sequences,” Journal of Difference Equations and Applications 9(10) (2003), 887–895, https://doi.org/10.1080/1023619021000041424. registry ↩

[4] “Ducci sequence,” Wikipedia, frozen revision 1369134091, https://en.wikipedia.org/wiki/Ducci_sequence. registry