Sum of squared digits

Take a positive integer x, square each of its digits, and sum. Now do the same to the result, over and over. What happens?

To find out, let’s write a little Python code that sums the squares of the digits.

    def G(x):
        return sum(int(d)**2 for d in str(x))

This function turns a number into a string, and iterates over the characters in the string, turning each one back into an integer and squaring it.

Now let’s plot the trajectories of the iterations of G.

    def iter(x, n):
        for _ in range(n):
            x = G(x)
        return x
    for x in range(1, 40):
        y = [iter(x, n) for n in range(1, 12)]
        plt.plot(y)

This produces the following plot.

For every starting value, the sequence of iterations either gets stuck on 1 or it goes in the cycle 4, 16, 37, 58, 89, 145, 42, 20, 4, … . This is a theorem of A. Porges published in 1945 [1].

To see how the sequences eventually hit 1 or 4, let’s modify our iteration function to stop at 4 rather than cycling.

    def iter4(x, n):
        for _ in range(n):
            if x != 4:
                x = G(x)
        return x

    for x in range(1, 40):
        y = [iter4(x, n) for n in range(1, 16)]
        plt.plot(y)

This produces the following plot.

Update: Here’s a better, or at least complementary, way to look at the iterations. Now the horizontal axis represents the starting points x and the points stacked vertically over x are the iterates of G starting at x.

    def orbit(x):
        pts = set()
        while x not in pts:
            pts.add(x)
            x = G(x)
        return pts  

    for x in range(1, 81):
        for y in orbit(x):
            plt.plot(x, y, "bo", markersize=2)
    plt.xlabel("$x$")
    plt.ylabel("Iterations of $x$")
    plt.savefig("porges3.png")

[1] Porges, A set of eight numbers, Amer. Math. Monthly, 52(1945) 379-382.

One thought on “Sum of squared digits

  1. When I was playing around with this my visualization (done with pen and paper instead of code) was a directed graph, with edges from x to G(x). I don’t think that plt has anything for this, but I’ll bet there’s a Javascript library out there that does. Time to update my skill set!

    Oh, and the next fun question that arises is “What happens when you change the base?”. Since I was pen-and-papering it I never got beyond doing it in base 8 (I believe there were two different [non-trivial] cycles a number could fall into). But with code one could explore a whole range of bases.

Leave a Reply

Your email address will not be published.