Sum of cubes of three positive integers in arithmetic progression in four ways?

Question

Consider the sums of cubes of three distinct positive integers in arithmetic progression, i.e. $a^3 + (a+b)^3 + (a+2b)^3$ where $a$ and $b$ are positive integers.
$$5643 = 1^3 + 9^3 + 17^3 = 6^3 + 11^3 + 16^3$$ is the smallest positive integer that has two such representations. $$255816 = 8^3 + 34^3 + 60^3 = 18^3 + 38^3 + 58^3 = 43^3 + 44^3 + 45^3$$ is the smallest that has three such representations. Is there a positive integer with four or more such representations, and if so what is the smallest?

The sequence of positive integers with one or more representations is OEIS sequence A306213. Those with two or more is A359055.

If representations where the three cubes do not need to be positive are allowed, then I know of examples with up to $11$ representations. Thus $$ \eqalign{42878854656 &= (-17232)^3 + 24^3 + 17280^3\cr &= (-6900)^3 + 144^3 + 7188^3\cr &= (-6704)^3 + 152^3 + 7008^3\cr &= (-3132)^3 + 528^3 + 4188^3\cr &= (-1812)^3 + 912^3 + 3636^3\cr &= (-1032)^3 + 1224^3 + 3480^3\cr &= (-292)^3 + 1552^3 + 3396^3\cr &= (-24)^3 + 1672^3 + 3368^3\cr &= 1038^3 + 2112^3 + 3186^3\cr &= 1635^3 + 2304^3 + 2973^3\cr &= 1728^3 + 2328^3 + 2928^3\cr }$$

Answer 1

I think there is no point in trying to guess any number. First you need to write a parametrization of the solutions of the equation.

$$(A-B)^3+A^3+(A+B)^3=(C-Q)^3+C^3+(C+Q)^3$$

$$A=4(24a^2-8ab+b^2)$$

$$B=177a^2-59ab+6b^2$$

$$C=4(33a^2-10ab+b^2)$$

$$Q=132a^2-49ab+6b^2$$

Then you can substitute it into the formula and then play with the coefficients. If this fails, then you will have to solve a system of nonlinear equations. There will be very cumbersome calculations.

There was a question. When there are solutions $ A−B>0 $ and $ C−Q>0 $

Each attempt at a solution gives a new formula for some reason. It didn't fit.

$$A=2(36a^2-4ab+b^2)$$

$$B=64a^2-ab+3b^2$$

$$C=2(32a^2+b^2)$$

$$Q=74a^2-11ab+3b^2$$

The following formula gives the necessary solutions.

$$A=528a^2-40ab+b^2$$

$$B=64a^2-25ab+3b^2$$

$$C=128a^2+b^2$$

$$Q=764a^2-95ab+3b^2$$

The general formula should contain 3 more parameters.

At the moment, we have managed to obtain such a formula.

$$A=64k^{4}t^{3}x^{2}+2ty^2$$

$$B=2k(27k^6-18k^{4}t^2+20k^2t^4+8t^6)x^2+(9k^2+2t^2)(3k^2-2t^2)xy+3ky^2$$

$$C=8tk^2(9k^4-4k^2t^2+4t^4)x^2+8kt(3k^2-2t^2)yx+2ty^2$$

$$Q=64k^3t^4x^2+(3k^2-2t^2)^2xy+3ky^2$$

Answer 2

The smallest integer with four representations is \begin{align} 57426732000&=331^3+2000^3+3669^3\\ &=1530^3+2460^3+3390^3\\ &=2150^3+2620^3+3090^3\\ &=2265^3+2640^3+3015^3. \end{align}

The smallest integer with five representations is \begin{align} 57629053893312000&=65340^3+213840^3+362340^3\\ &=95040^3+225720^3+356400^3\\ &=142992^3+243000^3+343008^3\\ &=233640^3+265320^3+297000^3\\ &=256575^3+267520^3+278465^3 \end{align}

To prove the first one, we can just search the range $[1,57426732000]$ very quickly with a sieve. By using the fact that any solution $N$ must be of form $N=3c(c^2+2d^2)$ for integers $c>d>0$ (see Greg Martin's comment), the search range $A\leq N \leq B$ gives bounds $$ A\leq 3c(c^2+2d^2)\leq 3c(c^2+2(c-1)^2)=3c(3c^2-4c+2)\\ 3c(c^2+2)\leq 3c(c^2+2d^2)\leq B $$ In our case this implies $185696\leq c \leq 267818$ and $1\leq d\leq c-1$ (we can also stop iterating over $d$ when $3c(c^2+2d^2)> B$). For each of $c,d$ in this range we increment count of representations of $3c(c^2+2d^2)$.

Following C++ implementation searches the given range in few seconds:

#include <iostream>
#include <map>
using namespace std;
const long long A = 1;
const long long B = 57426732000;
const int repre = 4;
map<long long, char> counts;
int main() {
long long c = 1;
// 3c^3-4c^2+2c&gt;=A/3
while (3 * (3 * c * c * c - 4 * c * c + 2 * c) &lt; A) {
    c += 1;
}
long long min_c = c;

c = min_c;
// c^3+2*c&lt;=B/3
while (3 * (c * c * c + 2 * c) &lt;= B) {
    c += 1;
}
long long max_c = c - 1;

// search the range
c = min_c;
while (c &lt;= max_c) {
    long long d = 1;
    while ((d &lt;= c - 1) &amp;&amp; (3*c*c*c+6*c*d*d&lt;=B)) { 
        //c ^ 3 + 2 * c * d^2 &lt;= B / 3
        long long N = 3 * c * (c * c + 2 * d * d);
        counts[N] += 1;
        d += 1;
    }
    c += 1;
}

int idx = 1;
for (auto&amp; N : counts) {
    if (N.second &gt;= repre) {
        std::cout &lt;&lt; idx &lt;&lt; &quot; &quot; &lt;&lt; N.first &lt;&lt; std::endl;
        idx += 1;
    }
}

return 0;

}

Note: The above code can give list of the A359055 sequence by printing terms with at least two representations (I've tested this and for repre=2 and B=173704947768 we get first 10000 terms).

Increasing the bounds we find that first couple of smallest $N$ with four representations are therefore $$ 57426732000,346380489216,459413856000,1235190627000,1550521764000,\dots. $$

As for the five representations, the sieve above would require too much memory, but we can modify it into a segmented sieve where we search intervals of fixed length. The following code snippet verified the smallest integer mentioned above (it gets faster over time, but still took couple hours to finish on my PC):

#include <iostream>
#include <map>
using namespace std;
map<long long, char> counts;
long long isqrt(long long n) {
    if (n == 0)
        return 0;
long long y = n;
long long x = n + 1;

while (y &lt; x) {
    x = y;
    y = (y + n / y) &gt;&gt; 1;
}

return x;

}
int main() {
int search_repre = 1;
int search_up_to = 5;

const long long segment_size = 1000000000000;
const long long start = 1;

long long A = start;
long long B = start + segment_size - 1;
while (true) {

    cout &lt;&lt; &quot;Sieving [&quot; &lt;&lt; A &lt;&lt; &quot;,&quot; &lt;&lt; B &lt;&lt; &quot;]&quot; &lt;&lt; endl;
    counts.clear();

    long long c = 1;
    // 3c^3-4c^2+2c&gt;=A/3
    while (3 * (3 * c * c * c - 4 * c * c + 2 * c) &lt; A) {
        c += 1;
    }
    long long min_c = c;

    c = min_c;
    // c^3+2*c&lt;=B/3
    while (3 * (c * c * c + 2 * c) &lt;= B) {
        c += 1;
    }
    long long max_c = c - 1;

    // search the range
    for(long long c = min_c; c &lt;= max_c; ++c) {

        // c ^ 3 + 2 * c * d ^ 2 &gt;= A/3
        long long min_d = (isqrt(A/(6*c) - (c * c)/2));
        if (min_d &lt; 1)
            min_d = 1;

        // c ^ 3 + 2 * c * d ^ 2 &lt;= B/3
        // integer division floors down, so we use ceiling and 
        // ceil(n/m)=floor((n-1)/m)+1
        // to make sure we do not miss some solutions when upper bound is round down
        long long max_d = isqrt((B-3*c*c*c-1)/(6*c)+1);
        if (max_d &gt; c - 1)
            max_d = c - 1;

        for(long long d = min_d; d &lt;= max_d; ++d) {
            //c ^ 3 + 2 * c * d^2 &lt;= B / 3
            long long N = 3 * c * (c * c + 2*d*d);
            counts[N] += 1;
        }
    }

    int idx = 1;
    for (auto&amp; N : counts) {
        if (N.second &gt;= search_repre) {
            std::cout &lt;&lt; idx &lt;&lt; &quot; &quot; &lt;&lt; N.first &lt;&lt; &quot; &quot; &lt;&lt; int(N.second) &lt;&lt; std::endl;
            idx += 1;
            search_repre += 1;

            if (search_repre &gt; search_up_to) {
                return 0;
            }
        }
    }

    A = B + 1;
    B += segment_size;
}

return 0;

}