Multiplicative Digital Root¶

The terminal single base-b digit reached by repeatedly replacing a nonnegative integer with the product of its digits, paired with multiplicative persistence as the number of iterations required to reach that fixed point.

Version: v2 · 2026-08-30 · History
Domain-specific #: 2330
Origin domain: number theory
Subdomain: digit dynamics
Aliases: Multiplicative digit root, Multiplicative root, Multiplicative digital-root function

Core Idea¶

For an integer base b >= 2, write a nonnegative integer n as digits d_k ... d_1 d_0, with 0 <= d_i < b and d_k != 0 when n > 0. Define the digit-product map.

F_b(n) = product from i=0 to k of d_i,

with F_b(0) = 0. Repeatedly apply F_b until the value is a single base-b digit. That terminal digit is the Multiplicative Digital Root of n in base b. The number of applications required is its multiplicative persistence. Thus, in base ten, 679 -> 378 -> 168 -> 48 -> 32 -> 6; the root is 6 and the persistence is 5.^[1]

The locked identity is chosen positional base + digit expansion + multiplication of all digits + repeat on the resulting integer + stop at a one-digit fixed point -> multiplicative digital root, with step count -> multiplicative persistence. Base choice is constitutive: an integer has different digit strings in different bases, so both root and persistence may change.

Termination for the ordinary unsigned representation is not conjectural. A multi-digit positive integer decreases after the digit-product map. If n has leading digit d_k and k+1 digits, then n >= d_k b^k, while F_b(n) <= d_k(b-1)^k < d_k b^k <= n. Repeated strict descent through nonnegative integers must eventually enter {0,1,...,b-1}, whose members are fixed points. The famous open question is different: for a fixed base such as ten, is the persistence bounded by one constant independent of how large the starting integer is? Sloane posed this boundedness problem in 1973.^[1]

Structural Signature¶

an integer base — b >= 2 fixes the digit alphabet and positional expansion;
a nonnegative starting integer — the standard map acts on ordinary unsigned base-b representations;
a canonical digit string — no arbitrary leading zeros are admitted, because leading zeros would force an artificial product of zero;
the digit-product operator — every represented digit contributes multiplicatively;
zero absorption — one zero digit sends the next iterate to zero, which remains fixed;
unit neutrality — digits equal to one do not change the immediate product but can affect representation length and search organization;
positional loss — multiplication forgets digit order after one step;
strict multi-digit descent — each multi-digit positive input maps to a smaller nonnegative integer;
finite iteration — descent terminates after a finite number of applications for every ordinary input;
a fixed-point set — precisely the single digits 0 through b-1 are terminal under the stopping convention;
the terminal value — the fixed digit is the multiplicative digital root;
the stopping time — the number of applications is multiplicative persistence;
a trajectory or orbit — the full sequence records how the map compresses the digit structure;
base dependence — the same abstract integer can have a different orbit in another base;
search symmetries — digit order does not affect the first product, allowing canonical sorting of candidate strings.

The root alone is a coarse invariant: many integers share it. Persistence retains one additional feature—distance to the terminal set—but still discards the intermediate orbit. The orbit is needed when studying predecessor structure, record searches, or arithmetic-dynamical behavior.

What It Is Not¶

Not the ordinary additive digital root. That map sums digits and has a modular shortcut in base ten; multiplication behaves differently.
Not multiplication of the number by its digits. Only the digits are multiplied together at each step.
Not exponentiation. Repeated multiplication here uses a changing digit multiset, not repeated copies of one factor.
Not multiplicative persistence. The root is the terminal digit; persistence is the step count.
Not base-independent. Decimal notation is not an intrinsic property of the integer.
Not sensitive to digit order on the first step. Permutations share the same first product, though leading-zero conventions matter.
Not an unproved termination claim. Finite descent proves termination; only global bounds on persistence remain open in many bases.
Not a cryptographic hash. It is highly many-to-one, structured, and trivial to collide.
Not automatically extended to negative integers. Signed-digit or sign-handling conventions create a different domain that must be specified.

Scope of Application¶

Multiplicative digital roots are studied in recreational number theory, digit functions, discrete dynamical systems, integer sequences, and computational searches. They provide a compact example in which a simple deterministic rule produces non-obvious record behavior and difficult boundedness questions. The process is also useful pedagogically for distinguishing an integer from its numeral representation and a terminal state from a stopping time.

Decimal research often focuses on the smallest integer with persistence p, the distribution of roots and persistence among ranges of integers, preimages of a target, and whether persistence exceeds the known record. The smallest decimal integer known to have persistence 11 is 277777788888899; its orbit ends in zero after eleven digit-product steps.^[2] The widely stated belief that decimal persistence never exceeds 11 is a conjecture, not a theorem. Search limits change over time, so this draft deliberately avoids freezing a largest verified range into the identity.

Search can discard large portions of numeral space. Because the first product is unchanged by digit permutation, candidate digits may be sorted. A zero gives immediate root zero with short remaining behavior. Digits one contribute no factor and generally inflate the numeral without changing the first product. Composite digits can sometimes be replaced by prime-digit factors to organize predecessor searches. These reductions help computation but must be proved for the particular minimality or boundedness question; they are not a substitute for searching all logically possible orbits.

Generalization to other bases changes the available prime factors, absorbing digit patterns, and possible record persistence. Lamont-Smith systematically compares ordinary and bijective base representations and defines absolute multiplicative persistence across bases.^[3] Those are variants built on the same iterate-to-one-digit structure.

Clarity¶

Persistence convention counts applications, so a single-digit input has persistence zero and root equal to itself. An input such as decimal 10 has persistence one because 1*0 = 0. Some informal descriptions count the number of displayed terms instead of arrows; that produces an off-by-one error.

The fixed point is determined by the stopping convention. For ordinary nonnegative numerals, every single digit satisfies F_b(d)=d. If one continued “multiplying digits” of a single digit, the same value would repeat forever; stopping records entry into this fixed-point set.

Leading zeros are excluded because they do not belong to the standard positional representation. Treating decimal 23 as 023 changes its product from 6 to 0 and therefore changes the function. A width-fixed machine representation with padding zeros defines another map.

Manages Complexity¶

The map turns an arbitrarily long digit string into one integer, then repeatedly compresses the result. Digit order disappears immediately, most magnitude information disappears quickly, and a finite state target summarizes the orbit. This makes it possible to ask global questions—basins of terminal digits, maximum stopping time, rare trajectories—without tracking ordinary arithmetic properties of every starting number.

The apparent simplicity also isolates the source of difficulty. Termination follows from size descent, but a uniform bound requires controlling how digit products create future numeral patterns across unbounded lengths. A huge starting number can shrink drastically in one step yet land on a specially structured product whose later digits sustain the orbit. The distinction between value descent and step-count boundedness is the central conceptual lesson.

Abstract Reasoning¶

If a numeral contains zero, its next value is zero and its total persistence is one unless it was already the digit zero.
If two numerals have the same multiset of digits, their first iterates and all subsequent iterates coincide.
If a numeral gains a digit one without positional side effects on other digits, its immediate product stays the same but its starting integer and representation change.
If the base changes, digit expansion changes, so neither root nor persistence is preserved in general.
If n has more than one digit, F_b(n) < n; therefore nontrivial cycles cannot occur in the ordinary domain.
If two inputs share a first iterate, their roots are equal and their persistence differs by at most the identical one-step prefix—indeed both equal one plus the persistence of that shared iterate.
If a claimed record is not minimal under digit permutations and neutral-digit deletion, the search normalization is incomplete.
If a root is odd in base ten, every digit on the last nontrivial product step must be odd; any even factor would make the product even.
If an orbit reaches a numeral containing both a factor-producing even digit and digit five in base ten, a later product can introduce a terminal zero once a zero digit appears, but the timing depends on the decimal representation of intermediate products.
Finding no persistence-12 input below a bound cannot prove no such input exists above it.

Knowledge Transfer¶

The exact construction transfers to every integer base after replacing the digit alphabet and expansion. It also extends to other digit maps—sum, product of powers, or signed-digit functions—but those have different fixed points and orbit structures. The general vocabulary is iteration, fixed point, basin, stopping time, and representation dependence.

The pattern resembles repeated compression in algorithms, but its mathematical content depends on positional digits and arithmetic multiplication. Treating any multiply-and-repeat process as a Multiplicative Digital Root would erase the base representation that defines the operation.

Examples¶

decimal 679: 679 -> 378 -> 168 -> 48 -> 32 -> 6; root 6, persistence 5;
decimal 9876: 9876 -> 3024 -> 0; root 0, persistence 2;
decimal 77: 77 -> 49 -> 36 -> 18 -> 8; root 8, persistence 4;
single digit 7: root 7, persistence 0;
decimal 10: root 0, persistence 1;
digit permutation: 39 and 93 both map first to 27 and therefore share the remaining orbit;
base change: the same integer written in binary has only zero and one digits, producing behavior unlike decimal;
non-example—additive root of 9876: repeated digit sums yield 3, not the multiplicative result;
failure—padded representation: using 0679 creates an artificial zero root.

Structural Tensions¶

rapid magnitude collapse vs. hard stopping-time bound — every orbit descends, yet a universal maximum number of steps is elusive;
integer identity vs. representation dependence — the input is an integer while the map acts on its chosen numeral;
terminal simplicity vs. trajectory richness — only b roots exist while preimage trees and persistence records are intricate;
commutative symmetry vs. positional encoding — digit order vanishes in multiplication but determines the starting numeral;
computational evidence vs. proof — enormous searches constrain counterexamples without settling unbounded space;
short definition vs. convention sensitivity — base, leading zeros, sign, and step counting must all be fixed.

Structural–Framed Character¶

Multiplicative Digital Root is structural. Once the integer domain, base, and numeral convention are chosen, the map, terminal digit, and step count follow deductively. Naming conventions do not affect the orbit.

Structural Core vs. Domain Accent¶

The structural core is representation-dependent map + iteration + finite descent -> fixed point and stopping time. The domain accent is positional integer digits, digit multiplication, numerical base, multiplicative root, and multiplicative persistence.

Iteration — the same digit-product rule is repeatedly applied to its own output.
Fixed Point — single digits form the terminal invariant set.
Transformation — F_b maps each integer to a new integer while discarding positional information.
Recursion — the root can be defined by applying the same rule until the base case n < b.
Exponentiation — prime-power structure helps analyze products but does not define the process.

The minimal prospective DAG uses strict part-of composition with prime:iteration: repeated self-application is constitutive, while the root is the terminal output of that process rather than a taxonomic kind of Iteration.

Relationships to Other Abstractions¶

Current abstraction Multiplicative Digital Root Domain-specific

Parents (1) — more general patterns this builds on

Multiplicative Digital Root is part of Iteration Prime

the same digit-product rule is repeatedly applied to its own output.

Hierarchy path (1) — routes to 1 parentless root

Multiplicative Digital Root → Iteration

Neighborhood in Abstraction Space¶

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

Family — Computational Number Theory & Enumeration (13 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-09-08

Not to Be Confused With¶

additive digital root;
additive persistence;
multiplicative persistence;
repeated multiplication of one number;
exponentiation;
product of prime factors;
cryptographic hash;
representation-independent integer invariant;
a proof that decimal persistence is bounded by 11;
signed or fixed-width variants without explicit conventions.

References¶

[1] N. J. A. Sloane, “The Persistence of a Number,” Journal of Recreational Mathematics 6(2) (1973), 97–98, https://neilsloane.com/doc/Me33.pdf. registry ↩a ↩b

[2] OEIS Foundation, sequence A003001, “Smallest number of multiplicative persistence n,” and related sequences A031346–A031347, https://oeis.org/A003001. registry ↩

[3] T. Lamont-Smith, “Multiplicative Persistence and Absolute Multiplicative Persistence,” Journal of Integer Sequences 24 (2021), Article 21.6.7, https://cs.uwaterloo.ca/journals/JIS/VOL24/Lamont/lamont5.html. registry ↩

[4] Gabriel Bonuccelli, Edson de Faria, and Charles Tresser, “On Sloane's Persistence Problem,” Experimental Mathematics 23 (2014), 363–378, https://arxiv.org/abs/1307.1188. registry

[5] “Multiplicative digital root,” Wikipedia, frozen evidence packet, https://en.wikipedia.org/wiki/Multiplicative_digital_root. registry