Power of Digital Root
The following interaction program determine the power digital root of your input x^y. Your input must be positive integer number of any digit up to 32,759 digits for base x and 28 digits for exponent y.
Let define dr[x] as digital root of x and dp[x, y] as power of digital root of . In this case, we call x as base and y as exponent. Then, based on the pattern of power digital root, we can say these properties:
Power of digital root is equal to the power of the digital root of the base:
dr[z] =dp[x, y] = dp[ dr[x], y]
For instance, we know that 225 = 15^2. Then, we can say that the digital root of 225 is equal to power digital root of 15 with exponent 2. In turn, this equal to the power of 6^2=36 and the digital root of 36 is 9. In formula, it becomes
dr = dr[15^2] = dp[15, 2] = dp[ dr, 2] = dp[6, 2] = dr = 9
The power of digital root has regular interesting pattern. The base has cycle length 9 and the exponent has cycle length 6. The power of digit root 1 is always 1, thus it has constant pattern whatever the power value is. Digit root 2 has repeating long pattern of 2-4-8-7-5-1. Digit root 3, 6 and 9 has constant pattern of 9 for any value of the exponent except 1. Digit root 4 has repeating pattern of 4-7-1 while digit root 7 has repeating pattern of 7-4-1. Digit root 8 has repeating short pattern of 8-1. [Compare this pattern to Division of Digital Root]
Looking the pattern of digital root below, the pattern of the base is repeating every 9 cycle length and the pattern of the exponent is repeating every 6 cycle length. This pattern can be formulated as the following property:
dr[z] = dp[x, y] = dp[ x+9, y+6] for x=1,2,3,..., y=2,3,4,...
For example, we can add the base with 9 and the exponent with 6 and still get the same digital root
dr = dr[15^2] = dp[15, 2] = dp[15+9, 2+6] = dp[24, 8] = dr=9.
In fact, we can write add only the base value with 9
dp[15, 2] = dp[24, 2] = dp[33, 2] = dp[42, 2] = 9.
Or, we can add only the exponent with 6
dp[15, 2] = dp[15, 8] = dp[15, 14] = dp[15, 20] = 9.
Practically, the pattern of digital root power cannot be produced using simple formula because of Mod function in most programming language usually cannot take very large number. One alternative is to use recursive or iterative method (macro) to produce such pattern above. [See the computer code].
The following code and explanation come from the contribution of Robert Sawyer ("r.e.s.") a math hobbyist from the USA.
The power of digital root of x^y can be computed without computing any powers, as follows:
Let dr(x) be the digital root of x, i.e. dr(x) = 1 + (x-1) mod 9. Then
dr(a*b) = dr( dr(a)* dr(b) ), so, if y > 1, then
dr(x^y) = dr( dr(x) * dr(x^(y-1)) ).
Therefore, a function f(x,y) can be defined recursively to compute dr(x^y) without evaluating any powers:
= dr(x) if y = 1
= dr(dr(x) * f(x, y - 1)) if y > 1.
In Excel Macro, the codes are shown below.
Function RecursiveDigitalPower(x As Integer, y As Integer) As Integer
' return digital root of x^y using the recursive property
' that dr(x^y) = dr( dr(x) * dr(x^(y-1)) ),
' which follows from dr(a*b) = dr( dr(a) * dr(b) )
' as explained by Robert Sawyer.
If y > 1 Then
RecursiveDigitalPower = DigitalRoot(DigitalRoot(x) * RecursiveDigitalPower(x, y - 1))
RecursiveDigitalPower = DigitalRoot(x)
Another way is to compute the power of digital root iteratively. A power of a number can be written as an iterative function for and the product of digital root has a nice property of . Therefore, we can write the power of digital root dr[z] = dr[x^y] as an iterative function.
Function IterativeDigitalPower (x_, y_)
'return the digital root of x^y (0 < x,y < 10^28)
' contribution of Robert Sawyer (“r.e.s.”)
x = CDec(x_)
y = CDec(y_)
z = CDec(1)
w = DigitalRoot(x)
For i = 1 To y
z = DigitalRoot (z * w)
IterativeDigitalPower = z
Still another better way to use the nice property of power digital root
dr[z] = dp[x, y] = dp[x+9, y+6]
as explained above. The code below is the best we got so far that it can accommodate the base up to 32,766 digits and exponent up to 28 digits.
Function DigitalPower(x, y)
'computes the digital root of x^y
' return the digital root of x^y (0 < x<10^32766, 0<y < 10^28)
' contribution of Robert Sawyer (“r.e.s.”)
Drx = DigitalRoot(x)
y = CDec(y)
yy = CInt(y - 6 * Int((y - 2) / 6))
z = CDec(1)
For i = 1 To yy
z = DigitalRoot(Z * Drx)
DigitalPower = z
One easy way to tested the function above is to place the following in a cell
which should then display 8 (i.e., the digital root of 8^999...9 with 28 9s). Changing the last digit of x from "8" to "9" should of course change the display to 9. The 999...98 with 32765 9s is chosen because it has a digital root of 8, and 8^n has a digital root that simply alternates between 1 and 8 when n is changed to n+1 or n-1, making it easy to verify that all the digits of y are being processed correctly; i.e., changing the last digit of y from "9" to "8" in the above line should change the display from 8 to 1.
I hope this historical note will prevent you from doing the same mistake. In my earlier attempt, I used simple iterative Macro to compute the power of digital root and it was my mistake to deduce that the power of digital roots has complexity pattern as shown below:
On the left side, it is almost regular but getting to the right (higher number of exponent) the pattern is irregular. The boundary between irregular and regular pattern is a curve with two asymptotes in the bases and in the power. The part of irregular pattern is really complex that one cannot predict what will be the next pattern. It is quite amazing that such random pattern can be produced using simple deterministic formula of digital root
The apparent complex pattern above may be generated due to inaccuracy of round off error as suggested by the comment below. If you are interested in complex pattern of digital root, check the next section on digital root of prime number.
I have a general interest in complexity and was intrigued by the
pattern that appeared to be associated with the powers of digital
roots that you published. However, the breakdown of the pattern was
not like the normal onset of chaos.
It was noticeable in the pattern that the solid colour pattern
associated with multiples of nine indicating a digital root of nine
broke down more quickly the larger the multiple. I counted the pixels
and checked the first break down for several multiples of nine on my
calculator. Each time I got a standard representation instead of the
full integer representation. When I reduced the power by one I got
the full integer number and when I multiplied this by nine manually
and calculated the digital root the answer was nine - not the
deviation the pattern indicated.
The maximum number of digits before swapping to standard notation was
14. In .NET and most recent versions of visual basic a long integer
can have up to 19 digits. However, this would not give a sufficient
range of numbers for the pattern you were trying to create. I suspect
therefore that you used double precision numbers which given a much
greater range but unfortunately are only accurate to 14 significant
You could get around the problem by using the big number class in Java
or writing your own long hand multiplication routines, a language like
Perl or Lisp would probably be ideal although I am sure you could do
it easily enough in VB.
Programme Director BIT
Information Systems & Information Technology
Faculty of Business, Computing and Information Management
London South Bank University
London SE1 0AA
Preferable reference for this tutorial is
Teknomo, Kardi (2005). Digital Root. https:\\people.revoledu.com\kardi\tutorial\DigitSum\