The square of a sum and the sum of cubes

Let’s start with a fun fact: Take the first \(n\) integers. Add them and then square the result; call this \(S\). Take the cube of each and add those numbers; call this \(C\). It will always be the case that \(S = C\). For instance, take \((1, 2, 3)\): \[(1 + 2 + 3)^2 = 6^2 = 36 \\ 1^3 + 2^3 + 3^3 = 1 + 8 + 27 = 36\]

This can be used to create problems such as “Find the values for a, b, and c if:” \[a^2 = a^3 \\ (a + b)^2 = a^3 + b^3 \\ (a + b + c) ^2 = a^3 + b^3 + c^3\]

Obviously, one solution is \((a, b, c) = (1, 2, 3)\). But that raises the question: Is that the only solution? Note that there are no constraints on possible values for a, b, and c in the original problem.

Starting with the first line, there are two solutions. We can find them by trial and error or by graphing, or we can find them through algebra: \[a^2 = a^3 \implies \\ a^3 – a^2 = 0 \implies a^2\cdot(a – 1) = 0 \implies \\ a^2 = 0 \wedge a – 1 = 0 \implies a \in \{0, 1\} \]

Using \(a =0\) erases it from the other equations, making the problem effectively: \[b^2 = b^3 \\ (b + c) ^2 = b^3 + c^3 \]

This has an obvious solution of \((b, c) = (1, 2)\). But note that b could also equal 0. That would make the problem, effectively, \(c^2 = c^3\). This gives us a total of four possible solutions: \[(a, b, c) \in \{(1, 2, 3), (0, 1, 2), (0, 0, 1), (0, 0, 0)\}\]

We can keep playing with this idea of 0 leading to so-called degenerate versions of the problem. We can actually use 0 for any of the three variables, and doing so effectively erases it from the problem. For instance, consider the solution set (1, 0, 2): \[1^2 = 1^3 = 1 \\ (1 + 0)^2 = 1^3 + 0^3  = 1 \\ (1 + 0 + 2) ^2 = 1^3 + 0^3 + 2^3 = 9\]

This gives us a total of \(2^3\) possible solutions: \[(a, b, c) \in \{(1, 2, 3), (0, 1, 2), (1, 0, 2), (1, 2, 0), \\  (0, 0, 1), (0, 1, 0), (1, 0, 0), (0, 0, 0)\}\]

We’re still not done yet. If we allow negative numbers (and,  again, there are no constraints in the original problem), we can cancel out values, since \(1 – 1 = 0\) and \(1^3 – (-1)^3 = 0\). We can’t do this entirely randomly, though; there’s an algorithm which I’ll detail below. However, what it means is for the problem above is that we have a total of thirteen possible solution sets: \[(a, b, c) \in \{(1, 2, 3), (0, 1, 2), (1, 0, 2), (1, 2, 0), \\  (0, 0, 1), (0, 1, 0), (1, 0, 0), (0, 0, 0), (1, 2, -2), \\ (0, 1, -1), (1, 0, -1), (1, -1, 0), (1, -1, 1)\}\]

This is an exhaustive list of solutions to the original problem. Note that we could add certain constraints, such as requiring that all numbers be positive, or all numbers be different.

The Algorithm

The list of solutions gets large rather quickly. For five variables, it’s 96; for six, it’s 267. There’s an algorithm for determining the sets, as suggested above; it can be seen in terms of a counter starting at 0. For each successively variable, we have up to three choices: Increase the current counter, decrease the current counter, or keep the counter the same. The option to decrease is not available if our current counter is 0.

That may be easier to understand by using the example above. The first digit is always 0 or 1; those are the only solutions to \(a^2 = a^3\). If our first digit is 1, our next digit can increase this to 2, decrease it to 0, or keep it at 1. We increase it simply by using 2; we can decrease it with -1; we can keep it the same with 0. If our second digit is 0, we have the same options we started with: 0 or 1.

Our second digit, then, can be 0, 1, or 2. If our second digit is 0, we have the same options again: 0 or 1. If our second digit is 1, we can increase to 2, decrease to 0, or stay at 1. If our second digit is 2, we can increase to 3, decrease to 1, or stay at 2.

The table below shows all possibilities, based on increasing, decreasing, or staying (in that order) at each step:

(1,_,_) (1,2,_) (1,2,3)
(1,2,-2)
(1,2,0)
(1,-1,_) (1,-1,1)
(1,-1,0)
(1,0,_) (1,0,2)
(1,0,-1)
(1,0,0)
(0,_,_) (0,1,_) (0,1,2)
(0,1,-1)
(0,1,0)
(0,0,_) (0,0,1)
(0,0,0)

Pseudocode for deriving all possible paths:

Let Counter = 0
Dimension Solutions(3^N)
For I = 1 to N
  Add a solution:
    Counter++
    Put Counter in Solutions(?) slot I
  If Counter > 0 then add a solution:
    Put Counter in Solutions(?) slot I
    Counter--
  Add a solution:
    Put Counter in Solutions(?) slot I
Next I

Because the counter can only be decreased if it’s greater than 0, the actual number of solutions is always less than \(3^n\). For the first four cases, the number of solutions is \(2^{n-1}+3^{n-1}\), but after that, the number of solutions falls below that mark, too.

The number of possible solutions is a series that exists for other mathematical reasons. This passage most closely resembles the problem above: “number of paths in an n X n grid from (0,0) to the line x=n-1, using only steps U=(1,1), H=(1,0) and D=(1,-1)”. U, H, and D correlate to increasing, staying, and decreasing, respectively.

Note that this particular problem starts at the third item in the series (2), not the first. Thus, if you wanted to know the number of possibilities for n = 10 (that is, \[(a + b + c + d + e + f + g + h + i + j)^2 = \\ a^3 + b^3 + c^3 + d^3 + e^3 + f^3 + g^3 + h^3 + i^3 + j^3\] ), you’d look at the twelfth element in the series (143,365).

Also keep in mind that this is a method for finding all of the solutions to the system of equations represented by: \[\left(\sum_1^i a_i\right)^2 = \sum_1^i \left(a_i\right)^3 | i_1^n \] not to the final equation itself. For instance, \[a^2 = a^3 \\ (a + b)^2 = a^3 + b^3\] has five solutions, but \[(a + b)^2 = a^3 + b^3\] by itself has an infinite number of solutions.

Testing the Algorithm

My go-to for testing quick programs is Excel VBA. It’s clunky and ugly as programming languages go, but I’m familiar enough with it that I don’t have to fret about GUI issues, and it has a handy worksheet for dropping results into as needed. My particular implementation requires adjusting the actual code for different values of n (and hence wouldn’t work for, say, n=100), but it does demonstrate that my algorithm generates valid solutions. It doesn’t prove that my solution set is exhaustive; I do welcome anyone to prove either that my algorithm is indeed exhaustive or if it misses solutions.

Here’s the code for n=7:

Sub SquaresCubes()
  Dim Step1, Step2, Step3, Step4, Step5, Step6, Step7, Stack
  Dim Cell1, Cell2, Cell3, Cell4, Cell5, Cell6, Cell7, RowPointer

  RowPointer = 1
  For Step1 = 0 To 1
    For Step2 = -1 To 1
    If Step1 + Step2 >= 0 Then
      For Step3 = -1 To 1
      If Step1 + Step2 + Step3 >= 0 Then
        For Step4 = -1 To 1
        If Step1 + Step2 + Step3 + Step4 >= 0 Then
          For Step5 = -1 To 1
          If Step1 + Step2 + Step3 + Step4 + Step5 >= 0 Then
            For Step6 = -1 To 1
            If Step1 + Step2 + Step3 + Step4 + Step5 + Step6 >= 0 Then
              For Step7 = -1 To 1
              If Step1 + Step2 + Step3 + Step4 + Step5 + Step6 + Step7 >= 0 Then

                Stack = Step1
                Cell1 = Step1
                PushPop Stack, Step2, Cell2
                PushPop Stack, Step3, Cell3
                PushPop Stack, Step4, Cell4
                PushPop Stack, Step5, Cell5
                PushPop Stack, Step6, Cell6
                PushPop Stack, Step7, Cell7

                Cells(RowPointer, 1) = "(" & Step1 & ", " & Cell2 & ", " & Cell3 & ", " & Cell4 & ", " _
                  & Cell5 & ", " & Cell6 & ", " & Cell7 & ")"
                Cells(RowPointer, 2) = (Cell1 + Cell2 + Cell3 + Cell4 + Cell5 + Cell6 + Cell7) ^ 2
                Cells(RowPointer, 3) = Cell1 ^ 3 + Cell2 ^ 3 + Cell3 ^ 3 + Cell4 ^ 3 + Cell5 ^ 3 + _ 
                  Cell6 ^ 3 + Cell7 ^ 3
                RowPointer = RowPointer + 1

              End If
              Next Step7
            End If
            Next Step6
          End If
          Next Step5
        End If
        Next Step4
      End If
      Next Step3
    End If
    Next Step2
  Next Step1

End Sub

Sub PushPop(ByRef StackVal, ByRef StepVal, ByRef CellVal)
  If StepVal = 1 Then
    StackVal = StackVal + 1
    CellVal = StackVal
  ElseIf StepVal = -1 Then
    CellVal = -StackVal
    StackVal = StackVal - 1
  Else
    CellVal = 0
  End If
End Sub

Leave a Comment

Your email address will not be published. Required fields are marked *