[2015-12-20] Project halted due to lack of results and interest (including mine).

Server status and client download

The Nagell-Ljunggren equation is a Diophantine equation of the form

1 + x + xor more compactly^{2}+ ... + x^{n-1}= y^{q}

(xadmitting integer solutions x, y, q ≥ 2, n ≥ 3.^{n}- 1)/(x - 1) = y^{q}

It has three known solutions (x, y, n, q):

(3, 11, 5, 2)The existence of other solutions remains an open question, thus making this an interesting target for computational search.

(7, 20, 4, 2)

(18, 7, 3, 3)

- In any solution besides (18, 7, 3, 3), the prime q divides p-1 where p is a prime factor of x. (Any composite exponent of y can be absorbed into y, leaving only one prime.) [1]
- In any new solution, n has at most 3 prime factors, counting multiplicities. [3]
- In any new solution, each of prime factor of n equals at least
29, and x ≥
10
^{6}. [2], Lemma 3 - No new solution has q = 2. This is one of the older results from Nagell and Ljunggren, and while it looks like an edge case, the effect is noticeable since there are lots primes next to highly composite numbers. [2]
- No new solution has q = 3 and n ≠ 5 mod 6. Another classical edge case. [2]

The problem space consists of points (x, n, q) fulfilling the aforementioned criteria. From each triplet we compute the corresponding y, and check if it is an integer. The latter is not quite as trivial as it seems here, since we are dealing with bignums and need to worry about rounding issues, but the basic idea is a rather brute-force search. Hence the problem ends up being more about work division and distribution than the bare math. To see that this method works, a test program is available.

[2014-12-28] A preliminary test based on Fermat's Little Theorem is now implemented, as suggested by R. Gerbicz. It has more than doubled overall speed, by weeding out candidates before going into bignums. Indeed, such tests with different moduli might be able to eliminate bignums altogether (cf. Hasse principle).

[2015-01-28] The pretest now uses up to 20 different prime moduli for a drastic speedup, eliminating bignums almost completely. As a consequence I had to increase the work unit size 400-fold :-j

Starting December 2014, I am looking for volunteers to run the client and join the quest for new solutions.

- Either The project aims to be platform independent to the extent that these languages are available. There is a simple Unix shell launcher which can be trivially replaced for other operating systems.
- Basic technical skills — I guess if you've read this far and understood most of it, I can trust your interest and ability :)
- Following the project updates (this page) every now and then. I.e. don't just leave it running and forget it, since there are bound to be updates.

You can participate without any registration, just pick a username and download the client.

At the moment, this is only a personal project, and I promise nothing besides eternal gratitude. However, if a new solution is found, this is big news for the math community. In that case, you will be credited as a co-discoverer, whether or not you actually discovered it.

Regardless of any solutions found, this is basic research that may end up in publications/theses or otherwise attain fame and fortune :)

As of 2014-12-30, the software makes use of multiple CPUs. The network client manages multiple worker processes, one for each work unit.

For a technical background: Julia has very nice provisions for parallelism, but it remains faster overall to run one worker per CPU. Parallelism in Python is even harder; for example, Python threads all run within a single process on one CPU. On the other hand, Python threads are useful here for the subprocess management.

Naturally, you can run the client on any number of different machines.

For now, there is only a username to provide some minimal identification. Besides being lazy on the server side, this idea actually follows from classical projects, such as Distributed.net, where you need not register to contribute.

In case of a failed connection, the client will generate a random work unit. Results are saved into files for sending later.

In addition, the state of the client is periodically saved, so you will not lose much work in a crash or a planned downtime.

Work units live in a 2D plane with the coordinates (x, n). Currently, each work units is 40000 x 40000 points. For each x, the client works out the list of permissible q's, and the range of n's is likewise filtered.

The current aim is that work units take a couple of hours to complete. However, your shiny new CPU might be a little faster, while older CPUs may take closer to a day on the larger units.

Note that older CPUs are indeed welcome; my crunchers range from an Atom to a Core 2 Duo. IMHO, one key point of these distributed projects is to show that a group of dedicated amateurs can stand up to supercomputers :) If it's 64-bit, it's probably fast enough for this.

The worker features a checksum for possible later verification that a given range has been completed. It represents the cumulative distance to an exact integer solution, and it is one of the key reasons why I did away with user registration.

The checksum is also a handy development feature to ensure consistency across changes in programming, given the same math. Unfortunately, it is not consistent between the Python and Julia workers, presumably due to subtle differences in rounding in the bignum libraries. This is why the client reports the worker language with results. Nevertheless, the rounding issue should not affect the veracity of actual solutions, as is evident from the test programs.

Generally, a project like this needs all kinds of help besides running the client, for example

- Math
- Programming (network, server, worker...)
- Server hosting and maintenance
- Marketing and fundraising (bitcoin:1DNaLSNBLYTPT8QizSCYtiXKHGwDHwtrf9)

- On
the Diophantine equation (x
^{n}- 1)/(x - 1) = y^{q}, Yann Bugeaud, Maurice Mignotte and Yves Roy, Pacific J. Math. 193 (2000), 257-268. - On
the Nagell–Ljunggren equation (x
^{n}- 1)/(x - 1) = y^{q}, Yann Bugeaud and Preda Mihǎilescu, Math. Scand. 101 (2007), 177-183. - The Nagell-Ljunggren equation via Runge's method, Michael A. Bennett, Aaron Levin 2013