The KHOKHAR Square Digital Root Transformation: 7443 a Fixed-Point Analysis of a 4-Digit Graph-Based Iterative Map

1. Introduction

Iterative maps on the digits of a number often produce unexpected stable constants or cycles; the best-known example is Kaprekar’s routine [1], whose four-digit version famously collapses almost every input to the constant 6174. This paper defines a related but different map, built from a square graph and digital-root arithmetic rather than from sorting the original digits directly. The map is simple enough to compute by hand, yet it has a nontrivial universal fixed point together with a small, exactly characterizable family of exceptional inputs.

The main results, established in the sections that follow, are summarized in the next theorem.

Theorem 1

(KHOKHAR Fixed Point and Convergence Theorem). Let T be the KHOKHAR Square Digital Root Transformation defined in Section 3. Then:

(a) 

$T\left(0000\right)=0000$ and $T\left(7443\right)=7443$, and these are theonlytwo fixed points of T.

(b) 

For every four-digit string n, some iterate $T^k\left(n\right)$ with $k\le 6$ lies in $\{0000,7443\}$; the bound 6 is sharp.

(c) 

$T\left(n\right)=0000$ if and only if the four edge digital roots of n (Section 3) are all equal to one another. Exactly 136 of the $10,000$ four-digit strings satisfy this condition. The other $9,864$ strings, including 7443 itself, satisfy $T^k\left(n\right)=7443$ for some k with $0\le k\le 6$.

Part (a) is the headline fixed-point result. Part (c) is the more delicate of the three claims: it would be natural to guess that repdigits alone feed into 0000, but the true condition is a fact about the four edge values , of which the repdigit case is only a special (if the most visually obvious) instance. Part (b) gives a concrete worst-case iteration bound.

2. Definitions and Notation

Let $n=d_1{d}_2{d}_3{d}_4$ be a four-digit string with digits $d_i\in \{0,1,\dots ,9\}$. Leading zeros are allowed and are always retained.

2.1. Digital Root

For a nonnegative integer x, the digital root$dr\left(x\right)$ is defined by

$$dr\left(x\right)=\left\{\begin{array}{cc}x,\hfill & 0\le x\le 9,\hfill \\ dr\left(s\right(x\left)\right),\hfill & x\ge 10,\hfill \end{array}\right.$$

where $s\left(x\right)$ is the sum of the decimal digits of x. In this paper x is always the sum of two digits, so $0\le x\le 18$, and the digital root reduces to the simple closed form

$$dr\left(x\right)=\left\{\begin{array}{cc}x,\hfill & x\le 9,\hfill \\ x-9,\hfill & 10\le x\le 18.\hfill \end{array}\right.$$

2.2. Descending and Ascending Arrangements

If $a,b,c,d$ are four single-digit numbers, then $desc(a,b,c,d)$ is the four-digit string obtained by writing $a,b,c,d$ in non-increasing order, and $asc(a,b,c,d)$ is the four-digit string obtained by writing them in non-decreasing order. Leading zeros are kept. For example,

$$desc(8,0,1,7)=8710,asc(8,0,1,7)=0178.$$

3. The KHOKHAR Square Digital Root Transformation

We place the digits $d_1,d_2,d_3,d_4$ on the four vertices of a square, in cyclic order (Figure 1). The four edges of the square are

$$(d_1,d_2),(d_2,d_3),(d_3,d_4),(d_4,d_1).$$

On each edge we compute the digital root of the sum of its two endpoint digits:

$$s_1=dr(d_1+d_2),s_2=dr(d_2+d_3),s_3=dr(d_3+d_4),s_4=dr(d_4+d_1).$$

We then form two four-digit strings from the multiset $\{s_1,s_2,s_3,s_4\}$:

$$D=desc(s_1,s_2,s_3,s_4),A=asc(s_1,s_2,s_3,s_4),$$

and define the transformation by

$$\begin{array}{|c|}\hline T\left(n\right)=D-A\\ \hline\end{array}$$

written as a four-digit string, with a leading zero if necessary. Because D and A arrange the same multiset of four digits, $D\ge A$ always, so $T\left(n\right)$ is a well-defined value between 0000 and 9999 (Lemma 1 below makes precise exactly when $D=A$).

Equivalently, this is the KHOKHAR Square Digital Root Formula:

$$\begin{array}{|c|}\hline T\left(d_1{d}_2{d}_3{d}_4\right)=desc\left(dr(d_i+d_{i+1})\right)-asc\left(dr(d_i+d_{i+1})\right)\\ \hline\end{array},i+1\mathrm{taken}\mathrm{mod}4.$$

4. Worked Example

We illustrate T starting from $n=1234$. Every step below was independently verified by hand and by computer.

Step 1: 1234

Edge sums: $1+2=3,2+3=5,3+4=7,4+1=5$. Digital roots: $3,5,7,5$.

$$D=7553,A=3557,T\left(1234\right)=7553-3557=3996.$$

Step 2: 3996

Edge sums: $3+9=12\to 3,9+9=18\to 9,9+6=15\to 6,6+3=9$. Digital roots: $3,9,6,9$.

$$D=9963,A=3699,T\left(3996\right)=9963-3699=6264.$$

Step 3: 6264

Edge sums: $6+2=8,2+6=8,6+4=10\to 1,4+6=10\to 1$. Digital roots: $8,8,1,1$.

$$D=8811,A=1188,T\left(6264\right)=8811-1188=7623.$$

Step 4: 7623

Edge sums: $7+6=13\to 4,6+2=8,2+3=5,3+7=10\to 1$. Digital roots: $4,8,5,1$.

$$D=8541,A=1458,T\left(7623\right)=8541-1458=7083.$$

Step 5: 7083

Edge sums: $7+0=7,0+8=8,8+3=11\to 2,3+7=10\to 1$. Digital roots: $7,8,2,1$.

$$D=8721,A=1278,T\left(7083\right)=8721-1278=7443.$$

Step 6: 7443 (fixed-point check)

Edge sums: $7+4=11\to 2,4+4=8,4+3=7,3+7=10\to 1$. Digital roots: $2,8,7,1$.

$$D=8721,A=1278,T\left(7443\right)=8721-1278=7443.$$

Hence 7443 is a fixed point of T, and 1234 reaches it after exactly five iterations.

5. Multiple Starting Points Converging to 7443

Different starting numbers follow different paths, yet all eventually reach the same nontrivial fixed point. Table 1 lists several examples; Table 2 shows two orbits realizing the maximal length identified in Theorem 2.

6. The Basin of Zero: Repdigits and Their Exact Characterization

6.1. The Repdigit Case

If all four digits are equal, say $n=aaaa$, every edge sum equals $a+a=2a$, so all four edge digital roots automatically coincide: $s_1=s_2=s_3=s_4=dr\left(2a\right)$. For example, take $n=5555$: every edge sum is $5+5=10$, with digital root 1, so all four edge values equal 1. Then $D=A=1111$, and

$$T\left(5555\right)=1111-1111=0000.$$

The same argument applies verbatim to every repdigit, so all ten strings $0000,1111,\dots ,9999$ map directly to 0000.

6.2. An Exact Characterization

The repdigit computation above suggests, at first glance, that $T\left(n\right)=0000$ precisely when n itself is a repdigit. This natural guess conflates a sufficient condition on the original digits $d_1,\dots ,d_4$ with the true necessary-and-sufficient condition, which lives one level down, on the edge values $s_1,\dots ,s_4$.

Lemma 1.

For single-digit values $s_1,s_2,s_3,s_4\in \{0,\dots ,9\}$,

$$desc(s_1,s_2,s_3,s_4)=asc(s_1,s_2,s_3,s_4)\iff s_1=s_2=s_3=s_4.$$

Proof. 

Sort the multiset $\{s_1,s_2,s_3,s_4\}$ as $a_1\le a_2\le a_3\le a_4$; then $asc=(a_1,a_2,a_3,a_4)$ and $desc=(a_4,a_3,a_2,a_1)$ termwise. These two 4-tuples agree exactly when $a_1=a_4$ and $a_2=a_3$; but $a_1\le a_2\le a_3\le a_4$ together with $a_1=a_4$ forces all four to be equal. The converse is immediate.    □

Corollary 1.

$T\left(n\right)=0000$ if and only if the four edge digital roots $s_1,s_2,s_3,s_4$ of n are all equal to one another; and whenever this happens, n reaches 0000 in a single step.

Repdigits satisfy the hypothesis of Corollary 1 for the reason given in Section 6.1: all four raw edge sums coincide (not merely their digital roots), because every edge joins two copies of the same digit. But Corollary 1 only requires the digital roots to coincide, and a digital root discards information , two different sums can share a root whenever they differ by 9. This opens the door to non-repdigit strings whose edge sums differ but whose digital roots happen to agree. For instance, $n=0191$ has edge sums $0+1=1,1+9=10,9+1=10,1+0=1$ , not all equal , but their digital roots are $1,1,1,1$, all equal, so $T\left(0191\right)=0000$ directly, even though 0191 is not a repdigit.

6.3. Enumerating the Full Basin

Exhaustive search (Section 8) over all $10,000$ four-digit strings finds exactly 136 strings satisfying the condition of Corollary 1 , not the 10 repdigits alone:

• 10 repdigits, where all four raw edge sums already coincide by symmetry;
• 90 further strings where the four raw edge sums still coincide exactly (typically alternating patterns such as $0101,0202,\dots$), bringing the total of this “trivial” type to 100;
• 36 additional strings where the raw edge sums do not all coincide, but their digital roots do, as in the 0191 example above.

Table 3 lists a representative sample spanning the full range; the complete list of 136 strings was produced by the program in Section 8.

Consequently, exactly $9,864$ four-digit strings converge to 7443; the 126 non-repdigit exceptions above join the 10 repdigits in the basin of 0000 instead.

7. A Sharp Convergence Bound

Beyond identifying the two fixed points, it is natural to ask how quickly an arbitrary input converges.

Theorem 2

(Sharp Convergence Bound). For every four-digit string n, $T^k\left(n\right)\in \{0000,7443\}$ for some $k\le 6$, and this bound is sharp: it is achieved by $1,096$ of the $10,000$ strings, including $n=0002$ (Table 2).

Table 4 gives the complete distribution, obtained by iterating T from every one of the $10,000$ starting strings and recording the number of steps needed to first land on 0000 or 7443.

Every string in the $\left\{0000\right\}$-basin reaches it in exactly one step (Corollary 1), so the full range of iteration counts in Table 4, up to and including the maximum of 6, is realized entirely among the $9,864$ strings converging to 7443. Table 2 exhibits two orbits, from 0002 and 0008, that realize this maximum.

8. Proof by Exhaustive Computation

Theorem 1 and Theorem 2 are established by direct computation: T is applied to every one of the ${10}^4$ possible four-digit strings, and every resulting orbit is traced until it reaches a fixed point. Because the entire domain has only $10,000$ elements, this is a complete case analysis, not a sample , there is no input left unchecked. The verification program below applies T to every four-digit string, records which of the two fixed points each orbit reaches, and counts how many steps that takes.

Listing 1: Verification script.

Running this program produces:

which confirms every numerical claim in Theorem 1 and Theorem 2: exactly two fixed points, a basin of size 136 for 0000 and $9,864$ for 7443, and a maximum convergence time of six iterations. No starting value failed to reach a fixed point within this bound, and no cycle of length greater than one was found anywhere in the state space, so these two fixed points are the only eventual behavior T can exhibit.

9. Applications in Computer Science

The construction above is primarily a recreational and pedagogical one, in the tradition of Kaprekar’s routine. Even so, both the transformation itself and the exhaustive-verification method used to analyze it connect naturally to several standard topics in computer science.

9.1. Finite Functional Graphs and Cycle Detection

Because T maps a finite state space of size ${10}^4$ to itself, repeatedly applying it to any starting point traces a path that must eventually enter a cycle , here, one of the two fixed points. The resulting structure (a collection of trees hanging off two single-node cycles) is exactly the “functional graph” or “rho shape” that underlies cycle-detection algorithms such as Floyd’s [2] and Brent’s [3] algorithms, which are used in practice for testing pseudorandom number generators, in Pollard’s rho method for integer factorization, and in detecting cycles in pointer-based data structures. Because the KHOKHAR transformation’s state space is small enough to enumerate completely (Section 8), it makes a convenient hand-sized instance on which to first implement and test a cycle-detection algorithm before applying it to state spaces too large to enumerate exhaustively.

9.2. Termination Proofs and Worst-Case Iteration Bounds

Theorem 2 is, in miniature, exactly the kind of claim a computer scientist must establish to certify that an iterative procedure terminates and to bound its running time: not just “it always stops,” but a concrete worst-case count, together with a witness showing the bound cannot be improved. The proof technique here , exhaustively simulating every possible input and recording the observed iteration counts , mirrors how worst-case bounds are frequently first discovered empirically before a general argument is sought. Kaprekar’s routine [1], whose analogous four-digit bound is seven iterations, is used pedagogically in much the same way; the KHOKHAR transformation offers a second, independent example with a different graph-theoretic flavor.

9.3. Exhaustive Search as a Verification Technique

The proof in Section 8 is a working example of exhaustive model checking: a universally quantified claim (“for all four-digit strings n, ...”) is verified not by a general argument but by checking every one of the finitely many cases on a computer. This is the same idea underlying model checkers used to verify finite-state hardware and protocol designs, and it is feasible here only because the state space (${10}^4$) is small enough to enumerate in well under a second. The construction is therefore a natural teaching example for discussing the boundary between problems small enough for brute-force verification and problems large enough (e.g. a state space of $2^{64}$) to require symbolic techniques, SAT/SMT solvers, or randomized/property-based testing tools, which sample rather than exhaust the input space.

9.4. A Self-Contained Programming Exercise

Implementing T requires only digit extraction, small modular (digital-root) arithmetic, sorting, and careful string formatting to preserve leading zeros , a compact but realistic set of tasks for an introductory programming exercise. Because the correct answer for any input is unambiguous and easy to check by hand (Section 4), the transformation is well suited to test-driven or unit-testing exercises, for example asserting that T("1234") == "3996", or that every orbit reaches a fixed point within six steps as predicted by Theorem 2.

9.5. A Cautionary Example for Hash and Checksum Design

On first inspection, T resembles the kind of ad hoc digit-mixing step sometimes proposed for a simple checksum or hash function: it combines all four input digits nonlinearly and appears to scramble them. The analysis above shows the opposite of good hashing behavior, however: iterating T collapses nearly every input onto just one of two possible outputs, and Corollary 1 shows that even a single application is far from uniform, since 136 distinct inputs are all mapped to the same output 0000. This makes the KHOKHAR transformation a useful negative example when teaching hash-function design: a function that “looks scrambled” by inspection can still have catastrophic collision behavior, which must be checked explicitly (as Section 8 does here) rather than assumed. T is offered purely as a recreational and pedagogical construction and should not be used as an actual checksum, hash function, or pseudorandom generator.

9.6. A Small Dataset for Visualization Practice

The basin sizes and iteration-count distribution computed in Section 6, Section 7 and Section 8 constitute a complete, self-generated dataset of $10,000$ labeled points, together with a discrete distribution over seven iteration-count values (Table 4). This provides ready material for practicing basic data-visualization tasks , for example, a bar chart of the two basin sizes, or a histogram of convergence lengths , without needing to source any external data.

10. Applications in Quantum Computing

The verification task of Section 8 , decide, for every one of $N=10,000$ four-digit strings, whether a given predicate holds , is a textbook instance of unstructured search, the problem class for which quantum computers offer a proven speedup. This section spells out how quantum search and counting algorithms apply to the KHOKHAR transformation, and is equally explicit about the limits of that connection at this problem size.

10.1. Grover-Accelerated Search Over the State Space

Classically, deciding whether a marked element exists among N unordered candidates requires $O\left(N\right)$ oracle evaluations in the worst case , exactly what Section 8 does, evaluating T on all $10,000$ strings. Grover’s algorithm [4] finds a marked element among N candidates using only $O\left(\sqrt{N}\right)$ oracle queries. Because $\sqrt{10,000}=100$ exactly, this is an unusually clean instance to state: a Grover search for, say, a counterexample to the six-iteration bound of Theorem 2, or for a member of the 136-element zero-basin of Corollary 1, would need on the order of 100 oracle calls in place of $10,000$ classical evaluations of T , a hundredfold reduction in queries, exactly matching the quadratic speedup Grover’s algorithm guarantees.

A caveat is essential here. Grover’s algorithm returns a marked element with high probability; it does not, by itself, certify that no marked element exists the way the classical exhaustive proof of Section 8 does. Matching the deductive certainty of brute-force enumeration requires either running Grover search to (probabilistic) exhaustion or using the quantum counting technique of Section 10.4, which bounds the exact number of solutions.

10.2. Reversible Oracle Construction

Quantum query algorithms act on a unitary oracle, but T itself is not reversible: Corollary 1 shows 136 distinct inputs collapse to the single output 0000, so T cannot be implemented directly as a quantum gate. The standard remedy [6] is to embed the classical function in a larger reversible map via an ancilla register,

$$U_T:|n\rangle |y\rangle ⟼|n\rangle |y\oplus T\left(n\right)\rangle ,$$

or, for a single-bit predicate such as “does n satisfy Corollary 1?”, a phase oracle $|n\rangle \mapsto {(-1)}^{f\left(n\right)}|n\rangle$. Building $U_T$ requires reversible circuits for each stage of the transformation: digit extraction, digital-root reduction of a sum in $[0,18]$, a four-element sorting network for desc and asc, and a final subtraction. Reversible adders such as the Cuccaro ripple-carry adder [7], together with reversible comparators of the same style, are exactly the primitives needed to assemble such a circuit. This makes the KHOKHAR transformation a compact, fully worked example for practicing the classical-function-to-reversible-oracle compilation step that underlies essentially every quantum query algorithm, including Grover’s.

10.3. Qubit Budget for a State-Space Index

Encoding a single four-digit string in binary-coded decimal costs $4\times 4=16$ qubits (four bits per digit); indexing the $10,000$ valid strings directly costs only $\lceil {log}_{2}10,000\rceil =14$ qubits. Either count is modest , comparable to circuit widths already exercised on current superconducting and trapped-ion hardware , though the arithmetic subcircuits of Section 10.2 would add nontrivial depth beyond the bare index register. The state space of the KHOKHAR transformation is therefore a plausible size for a circuit-design exercise (building $U_T$ and running Grover’s algorithm on a simulator or small device), even though, as Section 10.5 makes clear, it is far too small to need a quantum computer in practice.

10.4. Quantum Counting to Certify the Basin Sizes

Grover’s algorithm alone answers “does a marked element exist?”; quantum counting [5], which combines amplitude amplification with quantum phase estimation, estimates how many marked elements exist using the same $O\left(\sqrt{N}\right)$ query budget, and with enough precision can pin the count down exactly. Applied here, quantum counting offers a route to certifying the two basin sizes established by brute force in Section 8 , $\left|\mathrm{basin}\right(0000\left)\right|=136$ and $\left|\mathrm{basin}\right(7443\left)\right|=9,864$ , using asymptotically fewer oracle evaluations than the classical count. This illustrates that it is not only the “find one” step of a verification proof that admits a quantum speedup, but the “count them all” step as well.

10.5. A Note on Scale

None of the above should be read as a claim that a quantum computer is useful here: at $N=10,000$, the classical exhaustive check of Section 8 already completes in a small fraction of a second, and $\sqrt{N}=100$ oracle calls carries no practical advantage over $N=10,000$ classical ones at this scale, especially once the overhead of building $U_T$ is included. The value of the connection is pedagogical: the KHOKHAR transformation’s state space is small enough to reason about completely by hand or by brute force (Section 6, Section 7 and Section 8), yet structured simply enough to serve as a concrete worked example when teaching Grover’s algorithm, reversible oracle construction, and quantum counting , the same role Kaprekar’s routine and other small combinatorial puzzles have long played for classical-algorithms pedagogy.

11. Conclusion

We have introduced and exhaustively verified a new iterative map, the KHOKHAR Square Digital Root Transformation, defined by digital-root addition along the edges of a square together with a descending-minus-ascending digit-sort step. The map has exactly two fixed points, 0000 and 7443, and every four-digit string reaches one of them within at most six iterations. We gave a short direct proof (Lemma 1 and Corollary 1) characterizing exactly which strings reach 0000: those whose four edge digital roots already coincide. This condition holds for 136 strings , the 10 repdigits together with 126 further, non-repdigit strings. The remaining $9,864$ strings all converge to the single nontrivial constant 7443.

The KHOKHAR transformation has a unique nontrivial fixed point, 7443, reached (within six steps) by all but 136 of the $10,000$ four-digit strings.

Beyond its interest as a hand-computable digital constant in the tradition of Kaprekar’s routine, both the transformation and its exhaustive-verification proof serve as compact case studies relevant to functional-graph analysis, termination proofs, brute-force program verification, and hash-function pedagogy (Section 9), as well as to Grover-type quantum search and quantum counting (Section 10).